[Android] Experimental sync barrier detection for tracing

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

 // Copyright 2012 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.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;
 
     // Native class pointer set by the constructor of the SharedClient native class.
     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;
         }
         nativeDoRunLoopOnce(mMessagePumpDelegateNative, mDelayedScheduledTimeTicks);
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
     private void scheduleWork() {
+        updateWhetherQueueHasBlockingSyncBarrier();
+        if (mQueueHasBarrier) TraceEvent.instant("SystemMessageHandler:immediateWorkBlocked");
         sendEmptyMessage(SCHEDULED_WORK);
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
     private void scheduleDelayedWork(long delayedTimeTicks, long millis) {
         if (mDelayedScheduledTimeTicks != 0) {
             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);
     }
 
     private native void nativeDoRunLoopOnce(
             long messagePumpDelegateNative, long delayedScheduledTimeTicks);
 }