Use estimated vsync period on Android

ui/android/java/src/org/chromium/ui/VSyncMonitor.java

 // Copyright 2014 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;
 
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.os.Build;
 import android.os.Handler;
@@ skipping 23 matching lines @@
          * Called very soon after the start of the display's vertical sync period.
          * @param monitor The VSyncMonitor that triggered the signal.
          * @param vsyncTimeMicros Absolute frame time in microseconds.
          */
         public void onVSync(VSyncMonitor monitor, long vsyncTimeMicros);
     }
 
     private Listener mListener;
 
     // Display refresh rate as reported by the system.
-    private final long mRefreshPeriodNano;
+    private long mRefreshPeriodNano;
 
     private boolean mHaveRequestInFlight;
 
     // Choreographer is used to detect vsync on >= JB.
     private final Choreographer mChoreographer;
     private final Choreographer.FrameCallback mVSyncFrameCallback;
 
     // On ICS we just post a task through the handler (http://crbug.com/156397)
     private final Runnable mVSyncRunnableCallback;
     private long mGoodStartingPointNano;
@@ skipping 27 matching lines @@
         if (refreshRate <= 0) refreshRate = 60;
         mRefreshPeriodNano = (long) (NANOSECONDS_PER_SECOND / refreshRate);
 
         if (enableJBVSync && Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
             // Use Choreographer on JB+ to get notified of vsync.
             mChoreographer = Choreographer.getInstance();
             mVSyncFrameCallback = new Choreographer.FrameCallback() {
                 @Override
                 public void doFrame(long frameTimeNanos) {
                     TraceEvent.begin("VSync");
+                    // Display.getRefreshRate() is unreliable on some platforms.

[Sami, 2014/09/30 16:04:14]

Can we make this logic conditional on whether getRefreshRate() looks bogus or
not? I'd rather trust the system if it can give us a correct interval.

[jmanko, 2014/10/01 09:36:51]

Acknowledged.

+                    // Adjust refresh period- initial value is based on Display.getRefreshRate(),
+                    // after that it asymptotically approaches the real value.
+                    // Last refresh duration is capped at 30 fps
+                    long lastRefreshDurationNano =
+                        Math.min(frameTimeNanos - mGoodStartingPointNano,
+                                 34 * NANOSECONDS_PER_MILLISECOND);
+                    mRefreshPeriodNano = (mRefreshPeriodNano + lastRefreshDurationNano) / 2;

[Sami, 2014/09/30 16:04:14]

Instead of capping arbitrarily, can we just update the estimate only if we know
that we saw two consecutive vsyncs?

[jmanko, 2014/10/01 09:36:51]

You mean something like this?
long lastRefreshDurationNano = frameTimeNanos - mGoodStartingPointNano;
if (lastRefreshDurationNano < 34 * NANOSECONDS_PER_MILLISECOND)
    mRefreshPeriodNano = (mRefreshPeriodNano + lastRefreshDurationNano) / 2;

[Sami, 2014/10/01 09:39:34]

That would work. Please also make the |34 * NANOSECONDS_PER_MILLISECOND| a named
constant.

[no sievers, 2014/10/01 17:48:09]

Can't this be done easier and in a more robust way because we know whether we
requested a follow-up vsync tick after a given vsync tick?
I feel like we should rather not use mGoodStartingPointNano if it wasn't set in
the previous vsync.

                     mGoodStartingPointNano = frameTimeNanos;
                     onVSyncCallback(frameTimeNanos, getCurrentNanoTime());
                     TraceEvent.end("VSync");
                 }
             };
             mVSyncRunnableCallback = null;
         } else {
             // On ICS we just hope that running tasks is relatively predictable.
             mChoreographer = null;
             mVSyncFrameCallback = null;
@@ skipping 23 matching lines @@
     /**
      * Returns the time interval between two consecutive vsync pulses in microseconds.
      */
     public long getVSyncPeriodInMicroseconds() {
         return mRefreshPeriodNano / NANOSECONDS_PER_MICROSECOND;
     }
 
     /**
      * Determine whether a true vsync signal is available on this platform.
      */
-    private boolean isVSyncSignalAvailable() {
+    public boolean isVSyncSignalAvailable() {
         return mChoreographer != null;
     }
 
     /**
      * Request to be notified of the closest display vsync events.
      * Listener.onVSync() will be called soon after the upcoming vsync pulses.
      */
     public void requestUpdate() {
         postCallback();
     }
@@ skipping 71 matching lines @@
 
         if (currentTime + delay <= mLastPostedNano + mRefreshPeriodNano / 2) {
             delay += mRefreshPeriodNano;
         }
 
         mLastPostedNano = currentTime + delay;
         if (delay == 0) mHandler.post(mVSyncRunnableCallback);
         else mHandler.postDelayed(mVSyncRunnableCallback, delay / NANOSECONDS_PER_MILLISECOND);
     }
 }