Reland of Android: Add support for TraceEvent before the native library is loaded.

base/android/java/src/org/chromium/base/TraceEvent.java

 // Copyright 2014 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.
 
 package org.chromium.base;
 
 import android.os.Looper;
 import android.os.MessageQueue;
 import android.os.SystemClock;
 import android.util.Log;
 import android.util.Printer;
 
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 /**
  * Java mirror of Chrome trace event API. See base/trace_event/trace_event.h. Unlike the native
  * version, Java does not have stack objects, so a TRACE_EVENT() which does both TRACE_EVENT_BEGIN()
  * and TRACE_EVENT_END() in ctor/dtor is not possible.
- * It is OK to use tracing before the native library has loaded, but such traces will
- * be ignored. (Perhaps we could devise to buffer them up in future?).
+ * It is OK to use tracing before the native library has loaded, in a slightly restricted fashion.
+ * @see EarlyTraceEvent for details.
  */
 @JNINamespace("base::android")
 public class TraceEvent {
 
     private static volatile boolean sEnabled = false;
     private static volatile boolean sATraceEnabled = false; // True when taking an Android systrace.
 
     private static class BasicLooperMonitor implements Printer {
         @Override
         public void println(final String line) {
@@ skipping 141 matching lines @@
      */
     public static void registerNativeEnabledObserver() {
         nativeRegisterEnabledObserver();
     }
 
     /**
      * Notification from native that tracing is enabled/disabled.
      */
     @CalledByNative
     public static void setEnabled(boolean enabled) {
+        if (enabled) EarlyTraceEvent.disable();
         sEnabled = enabled;
         // Android M+ systrace logs this on its own. Only log it if not writing to Android systrace.
         if (sATraceEnabled) return;
         ThreadUtils.getUiThreadLooper().setMessageLogging(
                 enabled ? LooperMonitorHolder.sInstance : null);
     }
 
     /**
+     * May enable early tracing depending on the environment.
+     *
+     * Must be called after the command-line has been read.
+     */
+    public static void maybeEnableEarlyTracing() {
+        EarlyTraceEvent.maybeEnable();
+    }
+
+    /**
      * Enables or disabled Android systrace path of Chrome tracing. If enabled, all Chrome
      * traces will be also output to Android systrace. Because of the overhead of Android
      * systrace, this is for WebView only.
      */
     public static void setATraceEnabled(boolean enabled) {
         if (sATraceEnabled == enabled) return;
         sATraceEnabled = enabled;
         if (enabled) {
             // Calls TraceEvent.setEnabled(true) via
             // TraceLog::EnabledStateObserver::OnTraceLogEnabled
@@ skipping 47 matching lines @@
      */
     public static void finishAsync(String name, long id) {
         if (sEnabled) nativeFinishAsync(name, id);
     }
 
     /**
      * Triggers the 'begin' native trace event with no arguments.
      * @param name The name of the event.
      */
     public static void begin(String name) {
-        if (sEnabled) nativeBegin(name, null);
+        begin(name, null);
     }
 
     /**
      * Triggers the 'begin' native trace event.
      * @param name The name of the event.
      * @param arg  The arguments of the event.
      */
     public static void begin(String name, String arg) {
+        EarlyTraceEvent.begin(name);
         if (sEnabled) nativeBegin(name, arg);
     }
 
     /**
      * Triggers the 'end' native trace event with no arguments.
      * @param name The name of the event.
      */
     public static void end(String name) {
-        if (sEnabled) nativeEnd(name, null);
+        end(name, null);
     }
 
     /**
      * Triggers the 'end' native trace event.
      * @param name The name of the event.
      * @param arg  The arguments of the event.
      */
     public static void end(String name, String arg) {
+        EarlyTraceEvent.end(name);
         if (sEnabled) nativeEnd(name, arg);
     }
 
     private static native void nativeRegisterEnabledObserver();
     private static native void nativeStartATrace();
     private static native void nativeStopATrace();
     private static native void nativeInstant(String name, String arg);
     private static native void nativeBegin(String name, String arg);
     private static native void nativeEnd(String name, String arg);
     private static native void nativeBeginToplevel();
     private static native void nativeEndToplevel();
     private static native void nativeStartAsync(String name, long id);
     private static native void nativeFinishAsync(String name, long id);
 }