Expose VSync pausing through WindowAndroid and pause VSync during webVR presentation

ui/android/java/src/org/chromium/ui/base/WindowAndroid.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.ui.base;
 
 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
 import android.annotation.SuppressLint;
 import android.annotation.TargetApi;
@@ skipping 91 matching lines @@
     private final AccessibilityManager mAccessibilityManager;
 
     // Whether touch exploration is enabled.
     private boolean mIsTouchExplorationEnabled;
 
     // On KitKat and higher, a class that monitors the touch exploration state.
     private TouchExplorationMonitor mTouchExplorationMonitor;
 
     private AndroidPermissionDelegate mPermissionDelegate;
 
+    private boolean mPendingVSyncRequest;

[boliu, 2017/03/15 22:08:11]

hmm.. reading over this, I think it makes more sense to have all this logic in
native in BFS? java can just purely pass through for the set paused call.

[mthiesse, 2017/03/16 00:03:07]

So it couldn't only live in BFS, or WindowAndroid::OnVSync will keep requesting
VSync updates and black-holing them (which I guess wouldn't break anything, but
would be conceptually strange). We would have to make native WindowAndroid and
WindowAndroid::WindowBeginFrameSource both aware of the paused state.

Because of this I have a mild preference for leaving as is. Feel free to insist
though.

[boliu, 2017/03/16 00:45:44]

Actually, I see another issue with moving to native. Some of this code runs
before native library is loaded, and native may not be ready when paused. OK,
add a comment that's why the state is here.

Otherwise, I'd ask this to be moved to native like you suggest.

[mthiesse, 2017/03/16 15:36:05]

Done.

+    private boolean mVSyncPaused;
+
     /**
      * An interface to notify listeners of changes in the soft keyboard's visibility.
      */
     public interface KeyboardVisibilityListener {
         public void keyboardVisibilityChanged(boolean isShowing);
     }
     private LinkedList<KeyboardVisibilityListener> mKeyboardVisibilityListeners =
             new LinkedList<>();
 
     /**
      * An interface to notify listeners that a context menu is closed.
      */
     public interface OnCloseContextMenuListener {
         /**
          * Called when a context menu has been closed.
          */
         void onContextMenuClosed();
     }
 
     private final ObserverList<OnCloseContextMenuListener> mContextMenuCloseListeners =
             new ObserverList<>();
 
     private final VSyncMonitor.Listener mVSyncListener = new VSyncMonitor.Listener() {
         @Override
         public void onVSync(VSyncMonitor monitor, long vsyncTimeMicros) {
+            if (mVSyncPaused) {
+                mPendingVSyncRequest = true;
+                return;
+            }
             if (mNativeWindowAndroid != 0) {
                 nativeOnVSync(mNativeWindowAndroid,
                               vsyncTimeMicros,
                               mVSyncMonitor.getVSyncPeriodInMicroseconds());
             }
         }
     };
 
     /**
      * Extract the activity if the given Context either is or wraps one.
@@ skipping 342 matching lines @@
     /**
      * For window instances associated with an activity, notifies any listeners
      * that the activity has been started.
      */
     protected void onActivityStarted() {
         if (mNativeWindowAndroid == 0) return;
         nativeOnActivityStarted(mNativeWindowAndroid);
     }
 
     @CalledByNative
-    private void requestVSyncUpdate() {
+    protected void requestVSyncUpdate() {

[boliu, 2017/03/15 22:08:11]

keep private

[mthiesse, 2017/03/16 00:03:07]

Done.

+        if (mVSyncPaused) {
+            mPendingVSyncRequest = true;
+            return;
+        }
         mVSyncMonitor.requestUpdate();
     }
 
     /**
      * An interface that intent callback objects have to implement.
      */
     public interface IntentCallback {
         /**
          * Handles the data returned by the requested intent.
          * @param window A window reference.
@@ skipping 40 matching lines @@
     }
 
     /**
      * Returns a pointer to the c++ AndroidWindow object and calls the initializer if
      * the object has not been previously initialized.
      * @return A pointer to the c++ AndroidWindow.
      */
     public long getNativePointer() {
         if (mNativeWindowAndroid == 0) {
             mNativeWindowAndroid = nativeInit(mDisplayAndroid.getDisplayId());
+            if (mVSyncPaused) nativeSetVSyncPaused(mNativeWindowAndroid, true);

[boliu, 2017/03/15 22:08:11]

hmm, this doesn't look correct to me, why is vsync initially paused? what's
unpausing it then?

[mthiesse, 2017/03/16 00:03:07]

Well, whatever paused it is responsible for unpausing it, it's not initially
paused. If something wants to pause the vsync loop before the native
WindowAndroid is initialized I don't see why not.

[boliu, 2017/03/16 00:45:44]

Oh so the assumption is that native start out as unpaused? Why not not assume
that and just pass paused here unconditionally?

[mthiesse, 2017/03/16 15:36:06]

Done.

         }
         return mNativeWindowAndroid;
     }
 
     /**
      * Set the animation placeholder view, which we set to 'draw' during animations, such that
      * animations aren't clipped by the SurfaceView 'hole'. This can be the SurfaceView itself
      * or a view directly on top of it. This could be extended to many views if we ever need it.
      */
     public void setAnimationPlaceholderView(View view) {
@@ skipping 147 matching lines @@
      * setWillNotDraw(false) to ensure that the animation is drawn over the SurfaceView,
      * and otherwise we call setWillNotDraw(true).
      */
     private void refreshWillNotDraw() {
         boolean willNotDraw = !mIsTouchExplorationEnabled && mAnimationsOverContent.isEmpty();
         if (mAnimationPlaceholderView.willNotDraw() != willNotDraw) {
             mAnimationPlaceholderView.setWillNotDraw(willNotDraw);
         }
     }
 
+    /**
+     * Pauses/Unpauses the VSync loop. A paused VSync loop will stop the compositor for this window,

[boliu, 2017/03/15 22:08:11]

nit: it's not a loop (in my head at least).. so drop the "loop" part

[mthiesse, 2017/03/16 00:03:07]

Done.

+     * preventing requestAnimationFrame callbacks from firing, etc.
+     */
+    public void setVSyncPaused(boolean paused) {
+        mVSyncPaused = paused;

[boliu, 2017/03/15 22:08:11]

generally, these things have an early out when mVSyncPaused and paused are equal

[mthiesse, 2017/03/16 00:03:07]

Done.

+        if (!mVSyncPaused && mPendingVSyncRequest) requestVSyncUpdate();
+        if (mNativeWindowAndroid != 0) nativeSetVSyncPaused(mNativeWindowAndroid, paused);
+    }
+
     private native long nativeInit(int displayId);
     private native void nativeOnVSync(long nativeWindowAndroid,
                                       long vsyncTimeMicros,
                                       long vsyncPeriodMicros);
     private native void nativeOnVisibilityChanged(long nativeWindowAndroid, boolean visible);
     private native void nativeOnActivityStopped(long nativeWindowAndroid);
     private native void nativeOnActivityStarted(long nativeWindowAndroid);
+    private native void nativeSetVSyncPaused(long nativeWindowAndroid, boolean paused);
     private native void nativeDestroy(long nativeWindowAndroid);
 
 }