improvements of the FPS counter in the HUDLayer

cc/frame_rate_counter.cc

 // 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.
 
 #include "config.h"
 
 #include "cc/frame_rate_counter.h"
 
 #include <cmath>
 
@@ skipping 52 matching lines @@
         ++m_droppedFrameCount;
 }
 
 void FrameRateCounter::markEndOfFrame()
 {
     m_currentFrameNumber += 1;
 }
 
 bool FrameRateCounter::isBadFrameInterval(base::TimeDelta intervalBetweenConsecutiveFrames) const
 {
+    double delta = intervalBetweenConsecutiveFrames.InSecondsF();
     bool schedulerAllowsDoubleFrames = !Proxy::hasImplThread();
-    bool intervalTooFast = schedulerAllowsDoubleFrames && intervalBetweenConsecutiveFrames.InSecondsF() < kFrameTooFast;
-    bool intervalTooSlow = intervalBetweenConsecutiveFrames.InSecondsF() > kFrameTooSlow;
+    bool intervalTooFast = schedulerAllowsDoubleFrames ? delta < kFrameTooFast : delta <= 0.0;

[egraether, 2012/10/31 17:36:42]

In threaded compositing the intervalTooFast check was not active, because
double-frames are not possible. This however made negative and zero intervals
possible, which this fix prevents now.

+    bool intervalTooSlow = delta > kFrameTooSlow;
     return intervalTooFast || intervalTooSlow;
 }
 
 bool FrameRateCounter::isBadFrame(int frameNumber) const
 {
     return isBadFrameInterval(frameInterval(frameNumber));
 }
 
 void FrameRateCounter::getAverageFPSAndStandardDeviation(double& averageFPS, double& standardDeviation) const
 {
-    int frame = m_currentFrameNumber - 1;
+    int frameNumber = m_currentFrameNumber - 1;
+    int frameCount = 0;
+    double fpsVarianceNumerator = 0;
+
     averageFPS = 0;
-    int averageFPSCount = 0;
-    double fpsVarianceNumerator = 0;
+    standardDeviation = 0;
 
     // Walk backwards through the samples looking for a run of good frame
     // timings from which to compute the mean and standard deviation.
     //
     // Slow frames occur just because the user is inactive, and should be
     // ignored. Fast frames are ignored if the scheduler is in single-thread
     // mode in order to represent the true frame rate in spite of the fact that
     // the first few swapbuffers happen instantly which skews the statistics
     // too much for short lived animations.
     //
     // isBadFrame encapsulates the frame too slow/frame too fast logic.
-    while (1) {
-        if (!isBadFrame(frame)) {
-            averageFPSCount++;
-            base::TimeDelta secForLastFrame = m_timeStampHistory[frameIndex(frame)] -
-                                              m_timeStampHistory[frameIndex(frame - 1)];
-            double x = 1.0 / secForLastFrame.InSecondsF();
+
+    // Go through all available historical data.
+    while (frameIndex(frameNumber) != frameIndex(m_currentFrameNumber) && frameNumber >= 0) {
+        base::TimeDelta delta = frameInterval(frameNumber);
+
+        if (!isBadFrameInterval(delta)) {
+            frameCount++;
+            double x = 1.0 / delta.InSecondsF();
             double deltaFromAverage = x - averageFPS;
             // Change with caution - numerics. http://en.wikipedia.org/wiki/Standard_deviation
-            averageFPS = averageFPS + deltaFromAverage / averageFPSCount;
-            fpsVarianceNumerator = fpsVarianceNumerator + deltaFromAverage * (x - averageFPS);
-        }
-        if (averageFPSCount && isBadFrame(frame)) {
+            averageFPS += deltaFromAverage / frameCount;
+            fpsVarianceNumerator += deltaFromAverage * (x - averageFPS);
+        } else if (frameCount)
             // We've gathered a run of good samples, so stop.
             break;
-        }
-        --frame;
-        if (frameIndex(frame) == frameIndex(m_currentFrameNumber) || frame < 0) {
-            // We've gone through all available historical data, so stop.
-            break;
-        }
+        frameNumber--;
     }
 
-    standardDeviation = sqrt(fpsVarianceNumerator / averageFPSCount);
+    if (frameCount)
+        standardDeviation = sqrt(fpsVarianceNumerator / frameCount);
 }
 
-base::TimeTicks FrameRateCounter::timeStampOfRecentFrame(int n)
+base::TimeTicks FrameRateCounter::timeStampOfRecentFrame(int n) const
 {
     DCHECK(n >= 0);
     DCHECK(n < kTimeStampHistorySize);
     int desiredIndex = (frameIndex(m_currentFrameNumber) + n) % kTimeStampHistorySize;
     return m_timeStampHistory[desiredIndex];
 }
 
 }  // namespace cc