[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.Looper;
 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;
 
+    // The following members are used to detect and trace the presence of sync
+    // barriers in Android's MessageQueue. Note that this detection is
+    // experimental, temporary and intended only for diagnostic purposes.
+    private MessageQueue mMessageQueue;
+    private Field mMessageQueueMessageField;
+    private Field mMessageTargetField;
+    private boolean mQueueHasSyncBarrier;
+    private long mSyncBarrierTraceId;
+
     private SystemMessageHandler(long messagePumpDelegateNative) {
         mMessagePumpDelegateNative = messagePumpDelegateNative;
-    }
+        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 (mQueueHasSyncBarrier) 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 (mQueueHasSyncBarrier) 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() {
+        if (mMessageQueue == null) return;
+        // As barrier detection is only used for tracing, early out when tracing
+        // is disabled to avoid any potential performance penalties.
+        if (!TraceEvent.enabled()) {
+            mQueueHasSyncBarrier = false;
+            return;
+        }
+        Message queueHead = (Message)getField(mMessageQueue, mMessageQueueMessageField);
+        setqueueHasSyncBarrier(isSyncBarrierMessage(queueHead));
+    }
+
+    private boolean isSyncBarrierMessage(Message message) {
+        if (message == null) return false;
+        // Sync barrier messages have null targets.
+        return getField(message, mMessageTargetField) == null;
+    }
+
+    private void tryEnableSyncBarrierDetection() {
+        assert mMessageQueue == null;
+
+        boolean success = false;
+        try {
+            Method getQueueMethod = Looper.class.getMethod("getQueue", new Class[]{});
+            mMessageQueue = (MessageQueue)getQueueMethod.invoke(getLooper());
+
+            mMessageQueueMessageField = mMessageQueue.getClass().getDeclaredField("mMessages");
+            mMessageQueueMessageField.setAccessible(true);
+
+            mMessageTargetField = Message.class.getDeclaredField("target");
+            mMessageTargetField.setAccessible(true);
+
+            mSyncBarrierTraceId = hashCode();
+
+            success = true;
+        } 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 (IllegalArgumentException e) {
+            Log.e(TAG, "Illegal argument 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;
+        setqueueHasSyncBarrier(false);
+    }
+
+    private void setqueueHasSyncBarrier(boolean queueHasSyncBarrier) {
+        if (queueHasSyncBarrier == mQueueHasSyncBarrier) return;
+        mQueueHasSyncBarrier = queueHasSyncBarrier;
+        if (mQueueHasSyncBarrier) {
+            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);
 }