Android: Consolidate and simplify VSync logic

content/public/android/java/src/org/chromium/content/browser/ContentViewRenderView.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.content.browser;
 
 import android.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.PixelFormat;
-import android.os.Build;
 import android.os.Handler;
 import android.view.Surface;
 import android.view.SurfaceHolder;
 import android.view.SurfaceView;
 import android.widget.FrameLayout;
 
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
-import org.chromium.base.ObserverList;
-import org.chromium.base.ObserverList.RewindableIterator;
 import org.chromium.base.TraceEvent;
 import org.chromium.ui.base.WindowAndroid;
 
 /***
  * This view is used by a ContentView to render its content.
  * Call {@link #setCurrentContentViewCore(ContentViewCore)} with the contentViewCore that should be
  * managing the view.
  * Note that only one ContentViewCore can be shown at a time.
  */
 @JNINamespace("content")
-public class ContentViewRenderView extends FrameLayout {
+public class ContentViewRenderView extends FrameLayout implements WindowAndroid.VSyncClient {

[David Trainor- moved to gerrit, 2014/04/16 06:18:20]

Indent +8

[no sievers, 2014/04/25 22:23:33]

there's actually no line break here :)

     private static final int MAX_SWAP_BUFFER_COUNT = 2;
 
     // The native side of this object.
     private long mNativeContentViewRenderView;
     private final SurfaceHolder.Callback mSurfaceCallback;
 
     private final SurfaceView mSurfaceView;
-    private final VSyncAdapter mVSyncAdapter;
+    private final WindowAndroid mRootWindow;
 
     private int mPendingRenders;
     private int mPendingSwapBuffers;
     private boolean mNeedToRender;
 
     private ContentViewCore mContentViewCore;
 
     private final Runnable mRenderRunnable = new Runnable() {
         @Override
         public void run() {
             render();
         }
     };
 
     /**
      * Constructs a new ContentViewRenderView that should be can to a view hierarchy.
      * Native code should add/remove the layers to be rendered through the ContentViewLayerRenderer.
      * @param context The context used to create this.
      */
     public ContentViewRenderView(Context context, WindowAndroid rootWindow) {
         super(context);
         assert rootWindow != null;
         mNativeContentViewRenderView = nativeInit(rootWindow.getNativePointer());
         assert mNativeContentViewRenderView != 0;
 
+        mRootWindow = rootWindow;
+        rootWindow.setVSyncClient(this);
         mSurfaceView = createSurfaceView(getContext());
         mSurfaceView.setZOrderMediaOverlay(true);
         mSurfaceCallback = new SurfaceHolder.Callback() {
             @Override
             public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
                 assert mNativeContentViewRenderView != 0;
                 nativeSurfaceChanged(mNativeContentViewRenderView,
                         format, width, height, holder.getSurface());
                 if (mContentViewCore != null) {
                     mContentViewCore.onPhysicalBackingSizeChanged(
@@ skipping 15 matching lines @@
             }
 
             @Override
             public void surfaceDestroyed(SurfaceHolder holder) {
                 assert mNativeContentViewRenderView != 0;
                 nativeSurfaceDestroyed(mNativeContentViewRenderView);
             }
         };
         mSurfaceView.getHolder().addCallback(mSurfaceCallback);
 
-        mVSyncAdapter = new VSyncAdapter(getContext());
         addView(mSurfaceView,
                 new FrameLayout.LayoutParams(
                         FrameLayout.LayoutParams.MATCH_PARENT,
                         FrameLayout.LayoutParams.MATCH_PARENT));
     }
 
-    private class VSyncAdapter implements VSyncManager.Provider, VSyncMonitor.Listener {
-        private final VSyncMonitor mVSyncMonitor;
-        private boolean mVSyncNotificationEnabled;
-        private VSyncManager.Listener mVSyncListener;
-        private final ObserverList<VSyncManager.Listener> mCurrentVSyncListeners;
-        private final RewindableIterator<VSyncManager.Listener> mCurrentVSyncListenersIterator;
-
-        // The VSyncMonitor gives the timebase for the actual vsync, but we don't want render until
-        // we have had a chance for input events to propagate to the compositor thread. This takes
-        // 3 ms typically, so we adjust the vsync timestamps forward by a bit to give input events a
-        // chance to arrive.
-        private static final long INPUT_EVENT_LAG_FROM_VSYNC_MICROSECONDS = 3200;

[Sami, 2014/04/16 17:26:54]

Should probably verify with a trace, but does the fact that we now buffer input
events until vsync mean that we no longer need this hack for ICS?

[no sievers, 2014/04/25 22:23:33]

I thought that the deadline scheduler and retroactive BeginFrame eliminate the
need for this. But now that I look again, I'm actually not sure what it does :)

Note that this is used on JB and up in the code below but only when there are no
vsync subscribers (?).

You introduced it in 'Change-Id: I3df344b8a0fecda7c9c9a49be892875c01afeea8'
(patch set 2).

-
-        VSyncAdapter(Context context) {
-            mVSyncMonitor = new VSyncMonitor(context, this);
-            mCurrentVSyncListeners = new ObserverList<VSyncManager.Listener>();
-            mCurrentVSyncListenersIterator = mCurrentVSyncListeners.rewindableIterator();
+    @Override
+    public void onVSync(long vsyncTimeMicros) {
+      if (mNeedToRender) {
+        if (mPendingSwapBuffers + mPendingRenders <= MAX_SWAP_BUFFER_COUNT) {
+          mNeedToRender = false;
+          mPendingRenders++;
+          render();
+        } else {
+          TraceEvent.instant("ContentViewRenderView:bail");
         }
-
-        @Override
-        public void onVSync(VSyncMonitor monitor, long vsyncTimeMicros) {
-            if (mNeedToRender) {
-                if (mPendingSwapBuffers + mPendingRenders <= MAX_SWAP_BUFFER_COUNT) {
-                    mNeedToRender = false;
-                    mPendingRenders++;
-                    render();
-                } else {
-                    TraceEvent.instant("ContentViewRenderView:bail");
-                }
-            }
-
-            if (mVSyncListener != null) {
-                if (mVSyncNotificationEnabled) {
-                    for (mCurrentVSyncListenersIterator.rewind();
-                            mCurrentVSyncListenersIterator.hasNext();) {
-                        mCurrentVSyncListenersIterator.next().onVSync(vsyncTimeMicros);
-                    }
-                    mVSyncMonitor.requestUpdate();
-                } else {
-                    // Compensate for input event lag. Input events are delivered immediately on
-                    // pre-JB releases, so this adjustment is only done for later versions.
-                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
-                        vsyncTimeMicros += INPUT_EVENT_LAG_FROM_VSYNC_MICROSECONDS;
-                    }
-                    mVSyncListener.updateVSync(vsyncTimeMicros,
-                            mVSyncMonitor.getVSyncPeriodInMicroseconds());
-                }
-            }
-        }
-
-        @Override
-        public void registerVSyncListener(VSyncManager.Listener listener) {
-            if (!mVSyncNotificationEnabled) mVSyncMonitor.requestUpdate();
-            mCurrentVSyncListeners.addObserver(listener);
-            mVSyncNotificationEnabled = true;
-        }
-
-        @Override
-        public void unregisterVSyncListener(VSyncManager.Listener listener) {
-            mCurrentVSyncListeners.removeObserver(listener);
-            if (mCurrentVSyncListeners.isEmpty()) {
-                mVSyncNotificationEnabled = false;
-            }
-        }
-
-        void setVSyncListener(VSyncManager.Listener listener) {
-            mVSyncListener = listener;
-            if (mVSyncListener != null) mVSyncMonitor.requestUpdate();
-        }
-
-        void requestUpdate() {
-            mVSyncMonitor.requestUpdate();
-        }
+      }
     }
 
     /**
      * Sets the background color of the surface view.  This method is necessary because the
      * background color of ContentViewRenderView itself is covered by the background of
      * SurfaceView.
      * @param color The color of the background.
      */
     public void setSurfaceViewBackgroundColor(int color) {
         if (mSurfaceView != null) {
             mSurfaceView.setBackgroundColor(color);
         }
     }
 
     /**
      * Should be called when the ContentViewRenderView is not needed anymore so its associated
      * native resource can be freed.
      */
     public void destroy() {
+        mRootWindow.setVSyncClient(null);
         mSurfaceView.getHolder().removeCallback(mSurfaceCallback);
         nativeDestroy(mNativeContentViewRenderView);
         mNativeContentViewRenderView = 0;
     }
 
     /**
      * Makes the passed ContentView the one displayed by this ContentViewRenderView.
      * TODO(yfriedman): Remove once this rolls downstream and callers are updated.
      */
     @Deprecated
     public void setCurrentContentView(ContentView contentView) {
         setCurrentContentViewCore(contentView != null ? contentView.getContentViewCore() : null);
     }
 
 
     public void setCurrentContentViewCore(ContentViewCore contentViewCore) {
         assert mNativeContentViewRenderView != 0;
         mContentViewCore = contentViewCore;
 
         if (mContentViewCore != null) {
             mContentViewCore.onPhysicalBackingSizeChanged(getWidth(), getHeight());
-            mVSyncAdapter.setVSyncListener(mContentViewCore.getVSyncListener(mVSyncAdapter));
             nativeSetCurrentContentViewCore(mNativeContentViewRenderView,
                                             mContentViewCore.getNativeContentViewCore());
         } else {
             nativeSetCurrentContentViewCore(mNativeContentViewRenderView, 0);
         }
     }
 
     /**
      * This method should be subclassed to provide actions to be performed once the view is ready to
      * render.
@@ skipping 51 matching lines @@
 
             // The handler can be null if we are detached from the window.  Calling
             // {@link View#post(Runnable)} properly handles this case, but we lose the front of
             // queue behavior.  That is okay for this edge case.
             Handler handler = getHandler();
             if (handler != null) {
                 handler.postAtFrontOfQueue(mRenderRunnable);
             } else {
                 post(mRenderRunnable);
             }
-            mVSyncAdapter.requestUpdate();
         } else if (mPendingRenders <= 0) {
             assert mPendingRenders == 0;
             TraceEvent.instant("requestRender:later");
             mNeedToRender = true;
-            mVSyncAdapter.requestUpdate();
+            mRootWindow.requestVSyncUpdate();
         }
     }
 
     @CalledByNative
     private void onSwapBuffersCompleted() {
         TraceEvent.instant("onSwapBuffersCompleted");
 
         if (mPendingSwapBuffers == MAX_SWAP_BUFFER_COUNT && mNeedToRender) requestRender();
         if (mPendingSwapBuffers > 0) mPendingSwapBuffers--;
     }
@@ skipping 27 matching lines @@
             long nativeContentViewCore);
     private native void nativeSurfaceCreated(long nativeContentViewRenderView);
     private native void nativeSurfaceDestroyed(long nativeContentViewRenderView);
     private native void nativeSurfaceChanged(long nativeContentViewRenderView,
             int format, int width, int height, Surface surface);
     private native boolean nativeComposite(long nativeContentViewRenderView);
     private native boolean nativeCompositeToBitmap(long nativeContentViewRenderView, Bitmap bitmap);
     private native void nativeSetOverlayVideoMode(long nativeContentViewRenderView,
             boolean enabled);
 }