src/content/common/android/trace_event_binding.cc

   1 // Copyright (c) 2012 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 "content/common/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 {
  16
  17 const char kJavaCategory[] = "Java";
  18
  19 // Boilerplate for safely converting Java data to TRACE_EVENT data.
  20 class TraceEventDataConverter {
  21  public:
  22   TraceEventDataConverter(JNIEnv* env,
  23                           jstring jname,
  24                           jstring jarg)
  25       : env_(env),
  26         jname_(jname),
  27         jarg_(jarg),
  28         name_(env->GetStringUTFChars(jname, NULL)),
  29         arg_(jarg ? env->GetStringUTFChars(jarg, NULL) : NULL) {
  30   }
  31   ~TraceEventDataConverter() {
  32     env_->ReleaseStringUTFChars(jname_, name_);
  33     if (jarg_)
  34       env_->ReleaseStringUTFChars(jarg_, arg_);
  35   }
  36
  37   // Return saves values to pass to TRACE_EVENT macros.
  38   const char* name() { return name_; }
  39   const char* arg_name() { return arg_ ? "arg" : NULL; }
  40   const char* arg() { return arg_; }
  41
  42  private:
  43   JNIEnv* env_;
  44   jstring jname_;
  45   jstring jarg_;
  46   const char* name_;
  47   const char* arg_;
  48
  49   DISALLOW_COPY_AND_ASSIGN(TraceEventDataConverter);
  50 };
  51
  52 }  // namespace
  53
  54 static jboolean TraceEnabled(JNIEnv* env, jclass clazz) {
  55   return base::debug::TraceLog::GetInstance()->IsEnabled();
  56 }
  57
  58 static void StartATrace(JNIEnv* env, jclass clazz) {
  59   base::debug::TraceLog::GetInstance()->StartATrace();
  60 }
  61
  62 static void StopATrace(JNIEnv* env, jclass clazz) {
  63   base::debug::TraceLog::GetInstance()->StopATrace();
  64 }
  65
  66 static void Instant(JNIEnv* env, jclass clazz,
  67                     jstring jname, jstring jarg) {
  68   TraceEventDataConverter converter(env, jname, jarg);
  69   if (converter.arg()) {
  70     TRACE_EVENT_COPY_INSTANT1(kJavaCategory, converter.name(),
  71                               TRACE_EVENT_SCOPE_THREAD,
  72                               converter.arg_name(), converter.arg());
  73   } else {
  74     TRACE_EVENT_COPY_INSTANT0(kJavaCategory, converter.name(),
  75                               TRACE_EVENT_SCOPE_THREAD);
  76   }
  77 }
  78
  79 static void Begin(JNIEnv* env, jclass clazz,
  80                   jstring jname, jstring jarg) {
  81   TraceEventDataConverter converter(env, jname, jarg);
  82   if (converter.arg()) {
  83     TRACE_EVENT_COPY_BEGIN1(kJavaCategory, converter.name(),
  84                        converter.arg_name(), converter.arg());
  85   } else {
  86     TRACE_EVENT_COPY_BEGIN0(kJavaCategory, converter.name());
  87   }
  88 }
  89
  90 static void End(JNIEnv* env, jclass clazz,
  91                 jstring jname, jstring jarg) {
  92   TraceEventDataConverter converter(env, jname, jarg);
  93   if (converter.arg()) {
  94     TRACE_EVENT_COPY_END1(kJavaCategory, converter.name(),
  95                      converter.arg_name(), converter.arg());
  96   } else {
  97     TRACE_EVENT_COPY_END0(kJavaCategory, converter.name());
  98   }
  99 }
 100
 101 static void StartAsync(JNIEnv* env, jclass clazz,
 102                        jstring jname, jlong jid, jstring jarg) {
 103   TraceEventDataConverter converter(env, jname, jarg);
 104   if (converter.arg()) {
 105     TRACE_EVENT_COPY_ASYNC_BEGIN1(kJavaCategory,
 106                                   converter.name(),
 107                                   jid,
 108                                   converter.arg_name(),
 109                                   converter.arg());
 110   } else {
 111     TRACE_EVENT_COPY_ASYNC_BEGIN0(kJavaCategory,
 112                                   converter.name(),
 113                                   jid);
 114   }
 115 }
 116
 117 static void FinishAsync(JNIEnv* env, jclass clazz,
 118                         jstring jname, jlong jid, jstring jarg) {
 119   TraceEventDataConverter converter(env, jname, jarg);
 120   if (converter.arg()) {
 121     TRACE_EVENT_COPY_ASYNC_END1(kJavaCategory,
 122                                 converter.name(),
 123                                 jid,
 124                                 converter.arg_name(),
 125                                 converter.arg());
 126   } else {
 127     TRACE_EVENT_COPY_ASYNC_END0(kJavaCategory,
 128                                 converter.name(),
 129                                 jid);
 130   }
 131 }
 132
 133 bool RegisterTraceEvent(JNIEnv* env) {
 134   return RegisterNativesImpl(env);
 135 }