Add support for TraceEvent before the native library is loaded.

content/browser/android/tracing_controller_android.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/android/tracing_controller_android.h"
 
+#include <vector>
+
+#include "base/android/early_trace_event.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
+#include "content/browser/tracing/tracing_controller_impl.h"
 #include "content/public/browser/tracing_controller.h"
 #include "jni/TracingControllerAndroid_jni.h"
 
+using base::debug::TraceLog;

[dsinclair, 2015/02/09 21:11:20]

I believe this has now changed to be base::trace_event::TraceLog.

[Benoit L, 2015/02/10 15:31:35]

Done.

+
 namespace content {
+namespace {
+
+const char kCategoryGroup[] = "Java";
+
+// Adds the early Java trace events (i.e. before the native library was called)
+// to the TraceEvent log before the data gets written to disk.
+void OnDisableRecording(TraceLog* trace_log) {
+  const unsigned char* const category_group_enabled =
+      TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(kCategoryGroup);
+
+  TraceLog::GetInstance()->SetEnabled(

[dsinclair, 2015/02/09 21:11:20]

Why force the log to be enabled, is there a check we're doing on the tracing
side that this is to get past?

[Benoit L, 2015/02/10 15:31:35]

Yes, precisely, otherwise the AddTraceEventWithThreadAndTimestamp() calls would
be ignored in AddTraceEventInternal.
However, we only enable the "EarlyJava" category here that is not used anywhere
else (just made the change).
Thank you for pointing this out. I've also added a comment to make it clearer.

+      base::debug::CategoryFilter(kCategoryGroup), TraceLog::RECORDING_MODE,
+      base::debug::TraceOptions());
+
+  std::vector<base::android::EarlyTraceEvent> trace_events;
+  base::android::GetAllEarlyTraceEvents(&trace_events);
+
+  for (std::vector<base::android::EarlyTraceEvent>::const_iterator it =
+           trace_events.begin();
+       it != trace_events.end(); ++it) {
+    const base::android::EarlyTraceEvent& trace_event = *it;
+    const struct {
+      const char phase;
+      const base::TimeTicks timestamp;
+      const base::TimeTicks thread_time;
+    } phases[] = {
+      { TRACE_EVENT_PHASE_BEGIN, trace_event.begin_timestamp,
+        trace_event.begin_thread_time },
+      { TRACE_EVENT_PHASE_END, trace_event.end_timestamp,
+        trace_event.end_thread_time },
+    };
+
+    for (size_t i = 0; i < sizeof(phases) / sizeof(phases[0]); ++i) {
+      trace_log->AddTraceEventWithThreadIdAndTimestamp(
+          phases[i].phase, category_group_enabled, trace_event.name.c_str(),
+          trace_event_internal::kNoEventId,
+          trace_event.thread_id, phases[i].timestamp, phases[i].thread_time,
+          0, NULL, NULL, NULL, NULL, TRACE_EVENT_FLAG_COPY);
+    }
+  }
+
+  TraceLog::GetInstance()->SetDisabled();
+}
+
+}  // namespace
 
 static jlong Init(JNIEnv* env, jobject obj) {
   TracingControllerAndroid* profiler = new TracingControllerAndroid(env, obj);
   return reinterpret_cast<intptr_t>(profiler);
 }
 
 TracingControllerAndroid::TracingControllerAndroid(JNIEnv* env, jobject obj)
     : weak_java_object_(env, obj),
       weak_factory_(this) {}
 
 TracingControllerAndroid::~TracingControllerAndroid() {}
 
 void TracingControllerAndroid::Destroy(JNIEnv* env, jobject obj) {
   delete this;
 }
 
+void TracingControllerAndroid::SetupEarlyJavaTracing() {
+  TracingControllerImpl::GetInstance()->SetDisableRecordingCallback(
+      base::Bind(&OnDisableRecording));
+}
+
 bool TracingControllerAndroid::StartTracing(JNIEnv* env,
                                             jobject obj,
                                             jstring jcategories,
                                             jstring jtraceoptions) {
   std::string categories =
       base::android::ConvertJavaStringToUTF8(env, jcategories);
   base::debug::TraceOptions trace_options;
   trace_options.SetFromString(
       base::android::ConvertJavaStringToUTF8(env, jtraceoptions));
 
@@ skipping 65 matching lines @@
 static jstring GetDefaultCategories(JNIEnv* env, jobject obj) {
   return base::android::ConvertUTF8ToJavaString(env,
       base::debug::CategoryFilter::kDefaultCategoryFilterString).Release();
 }
 
 bool RegisterTracingControllerAndroid(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace content