Use estimated vsync period on Android

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

Index: ui/android/java/src/org/chromium/ui/VSyncMonitor.java
diff --git a/ui/android/java/src/org/chromium/ui/VSyncMonitor.java b/ui/android/java/src/org/chromium/ui/VSyncMonitor.java
index af8f87b5ffd898c832a1fa2f0db7cd590e50ca89..70fbd7b44969b0b78f4bceacd2ba8552c5f7d553 100644
--- a/ui/android/java/src/org/chromium/ui/VSyncMonitor.java
+++ b/ui/android/java/src/org/chromium/ui/VSyncMonitor.java
@@ -24,8 +24,14 @@ public class VSyncMonitor {
     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;

[jdduke (slow), 2014/10/08 03:17:02]

I don't think this is used any longer?

+
     private boolean mInsideVSync = false;
 
+    // Conservative guess about vsync's consecutivity.
+    // If true, next tick is guaranteed to be consecutive.
+    private boolean mConsecutiveVSync = false;
+
     /**
      * VSync listener class
      */
@@ -41,7 +47,7 @@ public class VSyncMonitor {
     private Listener mListener;
 
     // Display refresh rate as reported by the system.
-    private final long mRefreshPeriodNano;
+    private long mRefreshPeriodNano;
 
     private boolean mHaveRequestInFlight;
 
@@ -79,6 +85,8 @@ public class VSyncMonitor {
         mListener = listener;
         float refreshRate = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE))
                 .getDefaultDisplay().getRefreshRate();
+        final boolean useEstimatedRefreshPeriod = refreshRate < 30;

[jdduke (slow), 2014/10/08 03:17:02]

I see 30 both here and above in the MAX_VALID_VSYNC_PERIOD_NANOSECONDS
calculation. If they're at all coupled, could we pull out the 30 constant to
somewhere above? Or actually, it looks like the constant at the top is unused?

+
         if (refreshRate <= 0) refreshRate = 60;
         mRefreshPeriodNano = (long) (NANOSECONDS_PER_SECOND / refreshRate);
 
@@ -89,6 +97,15 @@ public class VSyncMonitor {
                 @Override
                 public void doFrame(long frameTimeNanos) {
                     TraceEvent.begin("VSync");
+                    if (useEstimatedRefreshPeriod && mConsecutiveVSync) {
+                        // 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;
+                        float lastRefreshDurationWeight = 0.1f;
+                        mRefreshPeriodNano += (long) (lastRefreshDurationWeight *

[jdduke (slow), 2014/10/08 03:17:02]

Hmm, I could be wrong, but don't you need to reweight this like:

mRefreshPeriodNano =  (1 - lastRefreshDurationWieght) * mRefreshPeriodNano +
lastRefreshDurationWeight * (lastRefreshDurationNano - mRefreshPeriodNano)?

Otherwise this will just grow without bound? What am I missing?

[Sami, 2014/10/08 10:14:51]

Hmm, I think that reduces to mRefreshPeriodNano = lastRefreshDurationNano / 2
which doesn't look right :) The current code is reducing the error between the
new period and the estimate. The bigger lastRefreshDurationWeight is, the faster
the convergence.

[jdduke (slow), 2014/10/08 13:06:00]

Of course, sigh, I should actually read the variable names =/ I glossed over the
subtraction term and thought it was computing the most recent period, rather
than the difference between the most recent period and the smoothed period.

+                                (lastRefreshDurationNano - mRefreshPeriodNano));
+                    }
                     mGoodStartingPointNano = frameTimeNanos;
                     onVSyncCallback(frameTimeNanos, getCurrentNanoTime());
                     TraceEvent.end("VSync");
@@ -186,6 +203,7 @@ public class VSyncMonitor {
         mHaveRequestInFlight = true;
         if (postSyntheticVSync()) return;
         if (isVSyncSignalAvailable()) {
+            mConsecutiveVSync = mInsideVSync;
             mChoreographer.postFrameCallback(mVSyncFrameCallback);
         } else {
             postRunnableCallback();