trace_event_binding.cc revision 0529e5d033099cbfc42635f6f6183833b09dff6e 
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/debug/trace_event_impl.h"
13#include "base/lazy_instance.h"
14#include "jni/TraceEvent_jni.h"
15
16namespace base {
17namespace android {
18
19namespace {
20
21const char kJavaCategory[] = "Java";
22const char kToplevelCategory[] = "toplevel";
23const char kLooperDispatchMessage[] = "Looper.dispatchMessage";
24
25// Boilerplate for safely converting Java data to TRACE_EVENT data.
26class TraceEventDataConverter {
27 public:
28  TraceEventDataConverter(JNIEnv* env,
29                          jstring jname,
30                          jstring jarg)
31      : env_(env),
32        jname_(jname),
33        jarg_(jarg),
34        name_(env->GetStringUTFChars(jname, NULL)),
35        arg_(jarg ? env->GetStringUTFChars(jarg, NULL) : NULL) {
36  }
37  ~TraceEventDataConverter() {
38    env_->ReleaseStringUTFChars(jname_, name_);
39    if (jarg_)
40      env_->ReleaseStringUTFChars(jarg_, arg_);
41  }
42
43  // Return saves values to pass to TRACE_EVENT macros.
44  const char* name() { return name_; }
45  const char* arg_name() { return arg_ ? "arg" : NULL; }
46  const char* arg() { return arg_; }
47
48 private:
49  JNIEnv* env_;
50  jstring jname_;
51  jstring jarg_;
52  const char* name_;
53  const char* arg_;
54
55  DISALLOW_COPY_AND_ASSIGN(TraceEventDataConverter);
56};
57
58class TraceEnabledObserver : public debug::TraceLog::EnabledStateObserver {
59  public:
60    virtual void OnTraceLogEnabled() OVERRIDE {
61      JNIEnv* env = base::android::AttachCurrentThread();
62      base::android::Java_TraceEvent_setEnabled(env, true);
63    }
64    virtual void OnTraceLogDisabled() OVERRIDE {
65      JNIEnv* env = base::android::AttachCurrentThread();
66      base::android::Java_TraceEvent_setEnabled(env, false);
67    }
68};
69
70base::LazyInstance<TraceEnabledObserver>::Leaky g_trace_enabled_state_observer_;
71
72}  // namespace
73
74static void RegisterEnabledObserver(JNIEnv* env, jclass clazz) {
75  bool enabled = debug::TraceLog::GetInstance()->IsEnabled();
76  base::android::Java_TraceEvent_setEnabled(env, enabled);
77  debug::TraceLog::GetInstance()->AddEnabledStateObserver(
78      g_trace_enabled_state_observer_.Pointer());
79}
80
81static void StartATrace(JNIEnv* env, jclass clazz) {
82  base::debug::TraceLog::GetInstance()->StartATrace();
83}
84
85static void StopATrace(JNIEnv* env, jclass clazz) {
86  base::debug::TraceLog::GetInstance()->StopATrace();
87}
88
89static void Instant(JNIEnv* env, jclass clazz,
90                    jstring jname, jstring jarg) {
91  TraceEventDataConverter converter(env, jname, jarg);
92  if (converter.arg()) {
93    TRACE_EVENT_COPY_INSTANT1(kJavaCategory, converter.name(),
94                              TRACE_EVENT_SCOPE_THREAD,
95                              converter.arg_name(), converter.arg());
96  } else {
97    TRACE_EVENT_COPY_INSTANT0(kJavaCategory, converter.name(),
98                              TRACE_EVENT_SCOPE_THREAD);
99  }
100}
101
102static void Begin(JNIEnv* env, jclass clazz,
103                  jstring jname, jstring jarg) {
104  TraceEventDataConverter converter(env, jname, jarg);
105  if (converter.arg()) {
106    TRACE_EVENT_COPY_BEGIN1(kJavaCategory, converter.name(),
107                       converter.arg_name(), converter.arg());
108  } else {
109    TRACE_EVENT_COPY_BEGIN0(kJavaCategory, converter.name());
110  }
111}
112
113static void End(JNIEnv* env, jclass clazz,
114                jstring jname, jstring jarg) {
115  TraceEventDataConverter converter(env, jname, jarg);
116  if (converter.arg()) {
117    TRACE_EVENT_COPY_END1(kJavaCategory, converter.name(),
118                     converter.arg_name(), converter.arg());
119  } else {
120    TRACE_EVENT_COPY_END0(kJavaCategory, converter.name());
121  }
122}
123
124static void BeginToplevel(JNIEnv* env, jclass clazz) {
125  TRACE_EVENT_BEGIN0(kToplevelCategory, kLooperDispatchMessage);
126}
127
128static void EndToplevel(JNIEnv* env, jclass clazz) {
129  TRACE_EVENT_END0(kToplevelCategory, kLooperDispatchMessage);
130}
131
132static void StartAsync(JNIEnv* env, jclass clazz,
133                       jstring jname, jlong jid, jstring jarg) {
134  TraceEventDataConverter converter(env, jname, jarg);
135  if (converter.arg()) {
136    TRACE_EVENT_COPY_ASYNC_BEGIN1(kJavaCategory,
137                                  converter.name(),
138                                  jid,
139                                  converter.arg_name(),
140                                  converter.arg());
141  } else {
142    TRACE_EVENT_COPY_ASYNC_BEGIN0(kJavaCategory,
143                                  converter.name(),
144                                  jid);
145  }
146}
147
148static void FinishAsync(JNIEnv* env, jclass clazz,
149                        jstring jname, jlong jid, jstring jarg) {
150  TraceEventDataConverter converter(env, jname, jarg);
151  if (converter.arg()) {
152    TRACE_EVENT_COPY_ASYNC_END1(kJavaCategory,
153                                converter.name(),
154                                jid,
155                                converter.arg_name(),
156                                converter.arg());
157  } else {
158    TRACE_EVENT_COPY_ASYNC_END0(kJavaCategory,
159                                converter.name(),
160                                jid);
161  }
162}
163
164bool RegisterTraceEvent(JNIEnv* env) {
165  return RegisterNativesImpl(env);
166}
167
168}  // namespace android
169}  // namespace base
170