[Android] Experimental sync barrier detection for tracing

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

Index: base/android/java/src/org/chromium/base/SystemMessageHandler.java
diff --git a/base/android/java/src/org/chromium/base/SystemMessageHandler.java b/base/android/java/src/org/chromium/base/SystemMessageHandler.java
index e1fbb0f4bed9538212313fdb374e81f0ac37f414..ed3b7230bdd4cc84c5f7bda2d17dd67afd48baf1 100644
--- a/base/android/java/src/org/chromium/base/SystemMessageHandler.java
+++ b/base/android/java/src/org/chromium/base/SystemMessageHandler.java
@@ -6,9 +6,17 @@ package org.chromium.base;
 
 import android.os.Handler;
 import android.os.Message;
+import android.os.MessageQueue;
+import android.util.Log;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 
 class SystemMessageHandler extends Handler {
 
+    private static final String TAG = "SystemMessageHandler";
+
     private static final int SCHEDULED_WORK = 1;
     private static final int DELAYED_SCHEDULED_WORK = 2;
 
@@ -16,12 +24,22 @@ class SystemMessageHandler extends Handler {
     private long mMessagePumpDelegateNative = 0;
     private long mDelayedScheduledTimeTicks = 0;
 
+    private MessageQueue mMessageQueue;
+    private Field mMessageQueueMessageField;
+    private Field mMessageTargetField;
+
+    private final long mSyncBarrierTraceId;
+    private boolean mQueueHasBarrier;
+
     private SystemMessageHandler(long messagePumpDelegateNative) {
         mMessagePumpDelegateNative = messagePumpDelegateNative;
-    }
+        mSyncBarrierTraceId = hashCode();
+        tryEnableSyncBarrierDetection();
+     }
 
     @Override
     public void handleMessage(Message msg) {
+        updateWhetherQueueHasBlockingSyncBarrier();
         if (msg.what == DELAYED_SCHEDULED_WORK) {
             mDelayedScheduledTimeTicks = 0;
         }
@@ -31,6 +49,8 @@ class SystemMessageHandler extends Handler {
     @SuppressWarnings("unused")
     @CalledByNative
     private void scheduleWork() {
+        updateWhetherQueueHasBlockingSyncBarrier();
+        if (mQueueHasBarrier) TraceEvent.instant("SystemMessageHandler:immediateWorkBlocked");
         sendEmptyMessage(SCHEDULED_WORK);
     }
 
@@ -41,16 +61,91 @@ class SystemMessageHandler extends Handler {
             removeMessages(DELAYED_SCHEDULED_WORK);
         }
         mDelayedScheduledTimeTicks = delayedTimeTicks;
+        updateWhetherQueueHasBlockingSyncBarrier();
+        if (mQueueHasBarrier) TraceEvent.instant("SystemMessageHandler:delayedWorkBlocked");
         sendEmptyMessageDelayed(DELAYED_SCHEDULED_WORK, millis);
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
     private void removeAllPendingMessages() {
+        updateWhetherQueueHasBlockingSyncBarrier();
         removeMessages(SCHEDULED_WORK);
         removeMessages(DELAYED_SCHEDULED_WORK);
     }
 
+    private void updateWhetherQueueHasBlockingSyncBarrier() {

[epennerAtGoogle, 2014/09/22 21:26:48]

If there is any cost to analyzing a message, we could check if tracing is
enabled and early out.

[jdduke (slow), 2014/09/22 21:32:57]

Ohh, I like that, didn't realize that was exposed from TraceEvent, I'll make the
change.

+        if (mMessageQueue == null) return;
+        final Message queueHead = (Message)getField(mMessageQueue, mMessageQueueMessageField);
+        final boolean queueHasBarrier = isBarrierMessage(queueHead);
+        setQueueHasBarrier(queueHasBarrier);
+    }
+
+    private boolean isBarrierMessage(Message message) {
+        if (message == null) return false;
+        // Sync barrier messages have null targets.
+        return getField(message, mMessageTargetField) == null;
+    }
+
+    private void tryEnableSyncBarrierDetection() {
+        boolean success = false;
+        try {
+            Class<?> looperClass = Class.forName("android.os.Looper");
+            Method getQueueMethod = looperClass.getMethod("getQueue", new Class[]{});
+            mMessageQueue = (MessageQueue)(getQueueMethod.invoke(getLooper()));
+
+            mMessageQueueMessageField = mMessageQueue.getClass().getDeclaredField("mMessages");
+            mMessageQueueMessageField.setAccessible(true);
+
+            mMessageTargetField = new Message().getClass().getDeclaredField("target");
+            mMessageTargetField.setAccessible(true);
+
+            success = true;
+        } catch (ClassNotFoundException e) {
+            Log.e(TAG, "Failed to find class: " + e);
+        } catch (NoSuchMethodException e) {
+            Log.e(TAG, "Failed to load method: " + e);
+        } catch (NoSuchFieldException e) {
+            Log.e(TAG, "Failed to load field: " + e);
+        } catch (InvocationTargetException e) {
+            Log.e(TAG, "Failed invocation: " + e);
+        } catch (IllegalAccessException e) {
+            Log.e(TAG, "Illegal access to reflected invocation: " + e);
+        } catch (RuntimeException e) {
+            Log.e(TAG, e.toString());
+        } finally {
+            if (!success) disableSyncBarrierDetection();
+        }
+    }
+
+    private void disableSyncBarrierDetection() {
+        Log.e(TAG, "Unexpected error with sync barrier detection, disabling.");
+        mMessageQueue = null;
+        mMessageQueueMessageField = null;
+        mMessageTargetField = null;
+        setQueueHasBarrier(false);
+    }
+
+    private void setQueueHasBarrier(boolean queueHasBarrier) {
+        if (queueHasBarrier == mQueueHasBarrier) return;
+        mQueueHasBarrier = queueHasBarrier;
+        if (mQueueHasBarrier) {
+            TraceEvent.startAsync("SyncBarrier", mSyncBarrierTraceId);
+        } else {
+            TraceEvent.finishAsync("SyncBarrier", mSyncBarrierTraceId);
+        }
+    }
+
+    private Object getField(Object object, Field field) {
+        try {
+            return field.get(object);
+        } catch (IllegalAccessException e) {
+            Log.e(TAG, "Failed field access: " + e);
+            disableSyncBarrierDetection();
+        }
+        return null;
+     }
+
     @CalledByNative
     private static SystemMessageHandler create(long messagePumpDelegateNative) {
         return new SystemMessageHandler(messagePumpDelegateNative);