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;
 import android.view.Choreographer;
 import android.view.WindowManager;
 
 import org.chromium.base.TraceEvent;
 
 /**
  * Notifies clients of the default displays's vertical sync pulses.
  * On ICS, VSyncMonitor relies on setVSyncPointForICS() being called to set a reasonable
  * approximation of a vertical sync starting point; see also http://crbug.com/156397.
  */
 @SuppressLint("NewApi")
 public class VSyncMonitor {
     private static final long NANOSECONDS_PER_SECOND = 1000000000;
     private static final long NANOSECONDS_PER_MILLISECOND = 1000000;
     private static final long NANOSECONDS_PER_MICROSECOND = 1000;
 
+    private static final long PERIOD_THRESHOLD_NANOSECONDS = NANOSECONDS_PER_SECOND / 30;

[Sami, 2014/10/01 11:42:49]

nit: Maybe call this something like MAX_VALID_VSYNC_PERIOD_NANOSECONDS to make
it more obvious what it is for.

+
     private boolean mInsideVSync = false;
 
     /**
      * VSync listener class
      */
     public interface Listener {
         /**
          * 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 23 matching lines @@
     public VSyncMonitor(Context context, VSyncMonitor.Listener listener, boolean enableJBVSync) {
         mListener = listener;
         float refreshRate = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE))
                 .getDefaultDisplay().getRefreshRate();
         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();
+            final boolean useEstimatedRefreshPeriod =
+                mRefreshPeriodNano > PERIOD_THRESHOLD_NANOSECONDS;
             mVSyncFrameCallback = new Choreographer.FrameCallback() {
                 @Override
                 public void doFrame(long frameTimeNanos) {
                     TraceEvent.begin("VSync");
+                    if (useEstimatedRefreshPeriod) {
+                        // Display.getRefreshRate() is unreliable on some platforms.
+                        // Adjust refresh period- initial value is based on Display.getRefreshRate()
+                        // after that it asymptotically approaches the real value.
+                        long lastRefreshDurationNano = frameTimeNanos - mGoodStartingPointNano;
+                        if (lastRefreshDurationNano <= PERIOD_THRESHOLD_NANOSECONDS) {
+                            mRefreshPeriodNano = (mRefreshPeriodNano + lastRefreshDurationNano) / 2;
+                        }
+                    }
                     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() {

[Sami, 2014/10/01 11:42:49]

Not needed?

         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);
     }
 }