[Android] Add an option to view the tracing record categories when running from python script.

content/public/android/java/src/org/chromium/content/browser/TracingControllerAndroid.java

 // 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.
 
 package org.chromium.content.browser;
 
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
@@ skipping 28 matching lines @@
  * Note that the name of these intents change depending on which application
  * is being traced, but the general form is [app package name].GPU_PROFILER_{START,STOP}.
  */
 @JNINamespace("content")
 public class TracingControllerAndroid {
 
     private static final String TAG = "TracingControllerAndroid";
 
     private static final String ACTION_START = "GPU_PROFILER_START";
     private static final String ACTION_STOP = "GPU_PROFILER_STOP";
+    private static final String ACTION_GET_CATEGORY = "GPU_PROFILER_LIST_CATEGORY";
     private static final String FILE_EXTRA = "file";
     private static final String CATEGORIES_EXTRA = "categories";
     private static final String RECORD_CONTINUOUSLY_EXTRA = "continuous";
     private static final String DEFAULT_CHROME_CATEGORIES_PLACE_HOLDER =
             "_DEFAULT_CHROME_CATEGORIES";
 
     private final Context mContext;
     private final TracingBroadcastReceiver mBroadcastReceiver;
     private final TracingIntentFilter mIntentFilter;
     private boolean mIsTracing;
@@ skipping 86 matching lines @@
         mShowToasts = showToasts;
 
         String filePath = generateTracingFilePath();
         if (filePath == null) {
           logAndToastError(
               mContext.getString(R.string.profiler_no_storage_toast));
         }
         return startTracing(filePath, showToasts, categories, recordContinuously);
     }
 
+    private void initializeNativeControllerIfNeeded() {
+        if (mNativeTracingControllerAndroid == 0) {
+            mNativeTracingControllerAndroid = nativeInit();
+        }
+    }
+
     /**
      * Start profiling to the specified file. Returns true on success.
      *
      * Only one TracingControllerAndroid can be running at the same time. If another profiler
      * is running when this method is called, it will be cancelled. If this
      * profiler is already running, this method does nothing and returns false.
      *
      * @param filename The name of the file to output the profile data to.
      * @param showToasts Whether or not we want to show toasts during this profiling session.
      * When we are timing the profile run we might not want to incur extra draw overhead of showing
      * notifications about the profiling system.
      * @param categories Which categories to trace. See TracingControllerAndroid::BeginTracing()
      * (in content/public/browser/trace_controller.h) for the format.
      * @param recordContinuously Record until the user ends the trace. The trace buffer is fixed
      * size and we use it as a ring buffer during recording.
      */
     public boolean startTracing(String filename, boolean showToasts, String categories,
             boolean recordContinuously) {
         mShowToasts = showToasts;
         if (isTracing()) {
             // Don't need a toast because this shouldn't happen via the UI.
             Log.e(TAG, "Received startTracing, but we're already tracing");
             return false;
         }
         // Lazy initialize the native side, to allow construction before the library is loaded.
-        if (mNativeTracingControllerAndroid == 0) {
-            mNativeTracingControllerAndroid = nativeInit();
-        }
+        initializeNativeControllerIfNeeded();
         if (!nativeStartTracing(mNativeTracingControllerAndroid, categories,
                 recordContinuously)) {
             logAndToastError(mContext.getString(R.string.profiler_error_toast));
             return false;
         }
 
         logAndToastInfo(mContext.getString(R.string.profiler_started_toast) + ": " + categories);
         mFilename = filename;
         mIsTracing = true;
         return true;
@@ skipping 18 matching lines @@
             Log.e(TAG, "Received onTracingStopped, but we aren't tracing");
             return;
         }
 
         logAndToastInfo(
                 mContext.getString(R.string.profiler_stopped_toast, mFilename));
         mIsTracing = false;
         mFilename = null;
     }
 
+    /**
+     * Get known category groups.
+     */
+    public void getCategoryGroups() {
+        // Lazy initialize the native side, to allow construction before the library is loaded.
+        initializeNativeControllerIfNeeded();
+        if (!nativeGetKnownCategoryGroupsAsync(mNativeTracingControllerAndroid)) {
+            onCategoryGroupsReceived(null);
+            return;
+        }
+    }
+
+    /**
+     * Called by native code when we receive the result of ping for known category groups.
+     */
+    @CalledByNative
+    protected void onCategoryGroupsReceived(String categoryList) {
+        if (categoryList != null)
+            Log.i(TAG, "{\"traceCategoriesList\": " + categoryList + "}");
+        else
+            Log.i(TAG, "Failed to fetch tracing category list.");
+    }
+
     @Override
     protected void finalize() {
         if (mNativeTracingControllerAndroid != 0) {
             nativeDestroy(mNativeTracingControllerAndroid);
             mNativeTracingControllerAndroid = 0;
         }
     }
 
     void logAndToastError(String str) {
         Log.e(TAG, str);
         if (mShowToasts) Toast.makeText(mContext, str, Toast.LENGTH_SHORT).show();
     }
 
     void logAndToastInfo(String str) {
         Log.i(TAG, str);
         if (mShowToasts) Toast.makeText(mContext, str, Toast.LENGTH_SHORT).show();
     }
 
     private static class TracingIntentFilter extends IntentFilter {
         TracingIntentFilter(Context context) {
             addAction(context.getPackageName() + "." + ACTION_START);
             addAction(context.getPackageName() + "." + ACTION_STOP);
+            addAction(context.getPackageName() + "." + ACTION_GET_CATEGORY);
         }
     }
 
     class TracingBroadcastReceiver extends BroadcastReceiver {
         @Override
         public void onReceive(Context context, Intent intent) {
             if (intent.getAction().endsWith(ACTION_START)) {
                 String categories = intent.getStringExtra(CATEGORIES_EXTRA);
                 if (TextUtils.isEmpty(categories)) {
                     categories = nativeGetDefaultCategories();
                 } else {
                     categories = categories.replaceFirst(
                             DEFAULT_CHROME_CATEGORIES_PLACE_HOLDER, nativeGetDefaultCategories());
                 }
                 boolean recordContinuously =
                         intent.getStringExtra(RECORD_CONTINUOUSLY_EXTRA) != null;
                 String filename = intent.getStringExtra(FILE_EXTRA);
                 if (filename != null) {
                     startTracing(filename, true, categories, recordContinuously);
                 } else {
                     startTracing(true, categories, recordContinuously);
                 }
             } else if (intent.getAction().endsWith(ACTION_STOP)) {
                 stopTracing();
+            } else if (intent.getAction().endsWith(ACTION_GET_CATEGORY)) {
+                getCategoryGroups();
             } else {
                 Log.e(TAG, "Unexpected intent: " + intent);
             }
         }
     }
 
     private long mNativeTracingControllerAndroid;
     private native long nativeInit();
     private native void nativeDestroy(long nativeTracingControllerAndroid);
     private native boolean nativeStartTracing(
             long nativeTracingControllerAndroid, String categories, boolean recordContinuously);
     private native void nativeStopTracing(long nativeTracingControllerAndroid, String filename);
+    private native boolean nativeGetKnownCategoryGroupsAsync(long nativeTracingControllerAndroid);
     private native String nativeGetDefaultCategories();
 }