Support tracking location of post tasks in Android

Android task runner posts Runnable tasks and the tasks are run by native
task runner. All these tasks are recorded with posted location as
post_task_android.cc. To track the correct posted location, this cl adds
new trace events to track the runnable class name.
Note that we still track the wrapper task runner in some cases like
ChainedTasks and AsyncTask$NamedFutureTask, which needs to be fixed.

BUG=1136635

Change-Id: I97b35b003ce7d5571ce4a44c54127da74400cf1e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2480715
Commit-Queue: ssid <ssid@chromium.org>
Reviewed-by: Tommy Nyquist <nyquist@chromium.org>
Cr-Commit-Position: refs/heads/master@{#821378}

base/android/java/src/org/chromium/base/task/PostTask.java

@@ -94,7 +94,7 @@ public class PostTask {
             TaskTraits postedTraits = taskTraits.withExplicitDestination();
             PostTaskJni.get().postDelayedTask(postedTraits.mPriority, postedTraits.mMayBlock,
                     postedTraits.mUseThreadPool, postedTraits.mExtensionId,
-                    postedTraits.mExtensionData, task, delay);
+                    postedTraits.mExtensionData, task, delay, task.getClass().getName());
         }
     }
 
@@ -269,6 +269,7 @@ public class PostTask {
     @NativeMethods
     interface Natives {
         void postDelayedTask(int priority, boolean mayBlock, boolean useThreadPool,
-                byte extensionId, byte[] extensionData, Runnable task, long delay);
+                byte extensionId, byte[] extensionData, Runnable task, long delay,
+                String runnableClassName);
     }
 }

base/android/java/src/org/chromium/base/task/TaskRunnerImpl.java

@@ -131,13 +131,15 @@ public class TaskRunnerImpl implements TaskRunner {
     public void postDelayedTask(Runnable task, long delay) {
         // Lock-free path when native is initialized.
         if (mNativeTaskRunnerAndroid != 0) {
-            TaskRunnerImplJni.get().postDelayedTask(mNativeTaskRunnerAndroid, task, delay);
+            TaskRunnerImplJni.get().postDelayedTask(
+                    mNativeTaskRunnerAndroid, task, delay, task.getClass().getName());
             return;
         }
         synchronized (mPreNativeTaskLock) {
             oneTimeInitialization();
             if (mNativeTaskRunnerAndroid != 0) {
-                TaskRunnerImplJni.get().postDelayedTask(mNativeTaskRunnerAndroid, task, delay);
+                TaskRunnerImplJni.get().postDelayedTask(
+                        mNativeTaskRunnerAndroid, task, delay, task.getClass().getName());
                 return;
             }
             // We don't expect a whole lot of these, if that changes consider pooling them.
@@ -224,14 +226,15 @@ public class TaskRunnerImpl implements TaskRunner {
         synchronized (mPreNativeTaskLock) {
             if (mPreNativeTasks != null) {
                 for (Runnable task : mPreNativeTasks) {
-                    TaskRunnerImplJni.get().postDelayedTask(nativeTaskRunnerAndroid, task, 0);
+                    TaskRunnerImplJni.get().postDelayedTask(
+                            nativeTaskRunnerAndroid, task, 0, task.getClass().getName());
                 }
                 mPreNativeTasks = null;
             }
             if (mPreNativeDelayedTasks != null) {
                 for (Pair<Runnable, Long> task : mPreNativeDelayedTasks) {
-                    TaskRunnerImplJni.get().postDelayedTask(
-                            nativeTaskRunnerAndroid, task.first, task.second);
+                    TaskRunnerImplJni.get().postDelayedTask(nativeTaskRunnerAndroid, task.first,
+                            task.second, task.getClass().getName());
                 }
                 mPreNativeDelayedTasks = null;
             }
@@ -259,7 +262,8 @@ public class TaskRunnerImpl implements TaskRunner {
                 boolean useThreadPool, byte extensionId, byte[] extensionData);
 
         void destroy(long nativeTaskRunnerAndroid);
-        void postDelayedTask(long nativeTaskRunnerAndroid, Runnable task, long delay);
+        void postDelayedTask(
+                long nativeTaskRunnerAndroid, Runnable task, long delay, String runnableClassName);
         boolean belongsToCurrentThread(long nativeTaskRunnerAndroid);
     }
 }

base/android/task_scheduler/post_task_android.cc

@@ -4,12 +4,15 @@
 
 #include "base/android/task_scheduler/post_task_android.h"
 
+#include "base/android/jni_string.h"
 #include "base/android_runtime_jni_headers/Runnable_jni.h"
 #include "base/base_jni_headers/PostTask_jni.h"
 #include "base/no_destructor.h"
 #include "base/run_loop.h"
+#include "base/strings/strcat.h"
 #include "base/task/post_task.h"
 #include "base/task/thread_pool/thread_pool_instance.h"
+#include "base/trace_event/base_tracing.h"
 
 namespace base {
 
@@ -65,24 +68,35 @@ void JNI_PostTask_PostDelayedTask(
     jbyte extension_id,
     const base::android::JavaParamRef<jbyteArray>& extension_data,
     const base::android::JavaParamRef<jobject>& task,
-    jlong delay) {
+    jlong delay,
+    const base::android::JavaParamRef<jstring>& runnable_class_name) {
   // This could be run on any java thread, so we can't cache |env| in the
   // BindOnce because JNIEnv is thread specific.
-  PostDelayedTask(FROM_HERE,
-                  PostTaskAndroid::CreateTaskTraits(
-                      env, priority, may_block, use_thread_pool, extension_id,
-                      extension_data),
-                  BindOnce(&PostTaskAndroid::RunJavaTask,
-                           base::android::ScopedJavaGlobalRef<jobject>(task)),
-                  TimeDelta::FromMilliseconds(delay));
+  PostDelayedTask(
+      FROM_HERE,
+      PostTaskAndroid::CreateTaskTraits(env, priority, may_block,
+                                        use_thread_pool, extension_id,
+                                        extension_data),
+      BindOnce(&PostTaskAndroid::RunJavaTask,
+               base::android::ScopedJavaGlobalRef<jobject>(task),
+               android::ConvertJavaStringToUTF8(runnable_class_name)),
+      TimeDelta::FromMilliseconds(delay));
 }
 
 // static
 void PostTaskAndroid::RunJavaTask(
-    base::android::ScopedJavaGlobalRef<jobject> task) {
+    base::android::ScopedJavaGlobalRef<jobject> task,
+    const std::string& runnable_class_name) {
   // JNIEnv is thread specific, but we don't know which thread we'll be run on
   // so we must look it up.
+  std::string event_name = base::StrCat({"JniPostTask: ", runnable_class_name});
+  TRACE_EVENT_BEGIN_WITH_FLAGS0(
+      "toplevel", event_name.c_str(),
+      TRACE_EVENT_FLAG_JAVA_STRING_LITERALS | TRACE_EVENT_FLAG_COPY);
   JNI_Runnable::Java_Runnable_run(base::android::AttachCurrentThread(), task);
+  TRACE_EVENT_END_WITH_FLAGS0(
+      "toplevel", event_name.c_str(),
+      TRACE_EVENT_FLAG_JAVA_STRING_LITERALS | TRACE_EVENT_FLAG_COPY);
 }
 
 }  // namespace base

base/android/task_scheduler/post_task_android.h

@@ -32,7 +32,8 @@ class BASE_EXPORT PostTaskAndroid {
 
   // We don't know ahead of time which thread this will run on so it looks up
   // the JNI environment and the bindings dynamically (albeit with caching).
-  static void RunJavaTask(base::android::ScopedJavaGlobalRef<jobject> task);
+  static void RunJavaTask(base::android::ScopedJavaGlobalRef<jobject> task,
+                          const std::string& runnable_class_name);
 
   DISALLOW_COPY_AND_ASSIGN(PostTaskAndroid);
 };

base/android/task_scheduler/task_runner_android.cc

@@ -4,6 +4,7 @@
 
 #include "base/android/task_scheduler/task_runner_android.h"
 
+#include "base/android/jni_string.h"
 #include "base/android/task_scheduler/post_task_android.h"
 #include "base/base_jni_headers/TaskRunnerImpl_jni.h"
 #include "base/bind.h"
@@ -53,11 +54,14 @@ void TaskRunnerAndroid::Destroy(JNIEnv* env) {
 void TaskRunnerAndroid::PostDelayedTask(
     JNIEnv* env,
     const base::android::JavaRef<jobject>& task,
-    jlong delay) {
+    jlong delay,
+    jstring runnable_class_name) {
   task_runner_->PostDelayedTask(
       FROM_HERE,
-      base::BindOnce(&PostTaskAndroid::RunJavaTask,
-                     base::android::ScopedJavaGlobalRef<jobject>(task)),
+      base::BindOnce(
+          &PostTaskAndroid::RunJavaTask,
+          base::android::ScopedJavaGlobalRef<jobject>(task),
+          android::ConvertJavaStringToUTF8(env, runnable_class_name)),
       TimeDelta::FromMilliseconds(delay));
 }
 

base/android/task_scheduler/task_runner_android.h

@@ -25,7 +25,8 @@ class TaskRunnerAndroid {
 
   void PostDelayedTask(JNIEnv* env,
                        const base::android::JavaRef<jobject>& task,
-                       jlong delay);
+                       jlong delay,
+                       jstring runnable_class_name);
 
   bool BelongsToCurrentThread(JNIEnv* env);