base/android/trace_event_binding.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/android/trace_event_binding.h"
   6
   7 #include <jni.h>
   8
   9 #include <set>
  10
  11 #include "base/debug/trace_event.h"
  12 #include "base/lazy_instance.h"
  13 #include "jni/TraceEvent_jni.h"
  14
  15 namespace base {
  16 namespace android {
  17
  18 namespace {
  19
  20 const char kJavaCategory[] = "Java";
  21
  22 // Boilerplate for safely converting Java data to TRACE_EVENT data.
  23 class TraceEventDataConverter {
  24  public:
  25   TraceEventDataConverter(JNIEnv* env,
  26                           jstring jname,
  27                           jstring jarg)
  28       : env_(env),
  29         jname_(jname),
  30         jarg_(jarg),
  31         name_(env->GetStringUTFChars(jname, NULL)),
  32         arg_(jarg ? env->GetStringUTFChars(jarg, NULL) : NULL) {
  33   }
  34   ~TraceEventDataConverter() {
  35     env_->ReleaseStringUTFChars(jname_, name_);
  36     if (jarg_)
  37       env_->ReleaseStringUTFChars(jarg_, arg_);
  38   }
  39
  40   // Return saves values to pass to TRACE_EVENT macros.
  41   const char* name() { return name_; }
  42   const char* arg_name() { return arg_ ? "arg" : NULL; }
  43   const char* arg() { return arg_; }
  44
  45  private:
  46   JNIEnv* env_;
  47   jstring jname_;
  48   jstring jarg_;
  49   const char* name_;
  50   const char* arg_;
  51
  52   DISALLOW_COPY_AND_ASSIGN(TraceEventDataConverter);
  53 };
  54
  55 }  // namespace
  56
  57 static jboolean TraceEnabled(JNIEnv* env, jclass clazz) {
  58   return base::debug::TraceLog::GetInstance()->IsEnabled();
  59 }
  60
  61 static void StartATrace(JNIEnv* env, jclass clazz) {
  62   base::debug::TraceLog::GetInstance()->StartATrace();
  63 }
  64
  65 static void StopATrace(JNIEnv* env, jclass clazz) {
  66   base::debug::TraceLog::GetInstance()->StopATrace();
  67 }
  68
  69 static void Instant(JNIEnv* env, jclass clazz,
  70                     jstring jname, jstring jarg) {
  71   TraceEventDataConverter converter(env, jname, jarg);
  72   if (converter.arg()) {
  73     TRACE_EVENT_COPY_INSTANT1(kJavaCategory, converter.name(),
  74                               TRACE_EVENT_SCOPE_THREAD,
  75                               converter.arg_name(), converter.arg());
  76   } else {
  77     TRACE_EVENT_COPY_INSTANT0(kJavaCategory, converter.name(),
  78                               TRACE_EVENT_SCOPE_THREAD);
  79   }
  80 }
  81
  82 static void Begin(JNIEnv* env, jclass clazz,
  83                   jstring jname, jstring jarg) {
  84   TraceEventDataConverter converter(env, jname, jarg);
  85   if (converter.arg()) {
  86     TRACE_EVENT_COPY_BEGIN1(kJavaCategory, converter.name(),
  87                        converter.arg_name(), converter.arg());
  88   } else {
  89     TRACE_EVENT_COPY_BEGIN0(kJavaCategory, converter.name());
  90   }
  91 }
  92
  93 static void End(JNIEnv* env, jclass clazz,
  94                 jstring jname, jstring jarg) {
  95   TraceEventDataConverter converter(env, jname, jarg);
  96   if (converter.arg()) {
  97     TRACE_EVENT_COPY_END1(kJavaCategory, converter.name(),
  98                      converter.arg_name(), converter.arg());
  99   } else {
 100     TRACE_EVENT_COPY_END0(kJavaCategory, converter.name());
 101   }
 102 }
 103
 104 static void StartAsync(JNIEnv* env, jclass clazz,
 105                        jstring jname, jlong jid, jstring jarg) {
 106   TraceEventDataConverter converter(env, jname, jarg);
 107   if (converter.arg()) {
 108     TRACE_EVENT_COPY_ASYNC_BEGIN1(kJavaCategory,
 109                                   converter.name(),
 110                                   jid,
 111                                   converter.arg_name(),
 112                                   converter.arg());
 113   } else {
 114     TRACE_EVENT_COPY_ASYNC_BEGIN0(kJavaCategory,
 115                                   converter.name(),
 116                                   jid);
 117   }
 118 }
 119
 120 static void FinishAsync(JNIEnv* env, jclass clazz,
 121                         jstring jname, jlong jid, jstring jarg) {
 122   TraceEventDataConverter converter(env, jname, jarg);
 123   if (converter.arg()) {
 124     TRACE_EVENT_COPY_ASYNC_END1(kJavaCategory,
 125                                 converter.name(),
 126                                 jid,
 127                                 converter.arg_name(),
 128                                 converter.arg());
 129   } else {
 130     TRACE_EVENT_COPY_ASYNC_END0(kJavaCategory,
 131                                 converter.name(),
 132                                 jid);
 133   }
 134 }
 135
 136 bool RegisterTraceEvent(JNIEnv* env) {
 137   return RegisterNativesImpl(env);
 138 }
 139
 140 }  // namespace android
 141 }  // namespace base