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 MAX_VALID_VSYNC_PERIOD_NANOSECONDS = NANOSECONDS_PER_SECOND / 30;
+
     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 > MAX_VALID_VSYNC_PERIOD_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;

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

+1 to what Sami said. Only doing the adjustments when we are somewhat certain
that we are dealing with a buggy Display.getRefreshRate() would be better.

+                        if (lastRefreshDurationNano <= MAX_VALID_VSYNC_PERIOD_NANOSECONDS) {
+                            mRefreshPeriodNano = (mRefreshPeriodNano + lastRefreshDurationNano) / 2;

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

Do you maybe want to use a bigger weight than 0.5 for the moving average
mRefreshPeriodNano?

[jmanko, 2014/10/02 12:02:29]

Sure, I can change that. Would 0.75 be enough?

[no sievers, 2014/10/02 19:51:42]

If you make sure that we don't have outliers (see discussion about other comment
and only measuring when we update this if mGoodStartingPointNano is really from
the previous vsync) then using the average will actually get us to the best
value possible over time.

How about just calculating the moving average over the last N values?
You only need to track the sum of the last N samples and the values of the last
N (= let's say 30 or so) samples. Then curr_avg = (sum - oldest_sample +
curr_sample) / N.

[jmanko, 2014/10/03 09:10:54]

That's already been done, the period is only updated on consecutive vsyncs.
See mConsecutiveVSync usage.
Is this still valid now, with outliers eliminated? Like you wrote above, using
all
the samples would eventually produce better result than last N average

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