cc: switch FPS counter graph back to a frame based X axis

cc/heads_up_display_layer_impl.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 "cc/heads_up_display_layer_impl.h"
 
 #include <limits>
 
 #include "base/stringprintf.h"
 #include "cc/debug_colors.h"
@@ skipping 157 matching lines @@
         drawDebugRects(canvas, layerTreeHostImpl()->debugRectHistory());
 }
 
 int HeadsUpDisplayLayerImpl::drawFPSCounter(SkCanvas* canvas, FrameRateCounter* fpsCounter)
 {
     const int padding = 4;
     const int gap = 6;
 
     const int fontHeight = m_fontAtlas.get() ? m_fontAtlas->fontHeight() : 0;
 
-    const int graphWidth = 120;
+    const int graphWidth = fpsCounter->timeStampHistorySize() - 3;
     const int graphHeight = 40;
 
     const int histogramWidth = 37;
 
     const int width = graphWidth + histogramWidth + 4 * padding;
     const int height = fontHeight + graphHeight + 4 * padding + 2;
 
     const int left = bounds().width() - width - 2;
     const int top = 2;
 
@@ skipping 44 matching lines @@
     paint.setColor(SkColorSetRGB(130, 130, 130));
     canvas->drawLine(graphBounds.left(), graphBounds.top() - 1, graphBounds.right(), graphBounds.top() - 1, paint);
     canvas->drawLine(graphBounds.left(), graphBounds.bottom(), graphBounds.right(), graphBounds.bottom(), paint);
 
     // Draw 60fps line.
     const double top60 = graphBounds.top() + graphBounds.height() * (1 - ((60 - loFPS) / (hiFPS - loFPS))) - 1;
     paint.setColor(SkColorSetRGB(100, 100, 100));
     canvas->drawLine(graphBounds.left(), top60, graphBounds.right(), top60, paint);
 
     // Collect graph and histogram data.
-    double x = 0;
-    const double timeScale = 60; // in pixels/second
+    int x = 0;
     SkPath path;
 
     m_minFPS = std::numeric_limits<double>::max();
     m_maxFPS = 0;
 
     const int histogramSize = 20;
     double histogram[histogramSize] = {0};
     double maxBucketValue = 0;
 
-    for (int i = fpsCounter->timeStampHistorySize() - 2; i > 0 && x <= graphBounds.width(); --i) {
+    for (int i = 1; i < fpsCounter->timeStampHistorySize() - 1; ++i) {
         base::TimeDelta delta = fpsCounter->timeStampOfRecentFrame(i + 1) - fpsCounter->timeStampOfRecentFrame(i);
 
         // Skip this particular instantaneous frame rate if it is not likely to have been valid.
         if (!fpsCounter->isBadFrameInterval(delta)) {
 
             double fps = 1.0 / delta.InSecondsF();
 
             m_minFPS = std::min(fps, m_minFPS);
             m_maxFPS = std::max(fps, m_maxFPS);
 
             // Clamp the FPS to the range we want to plot visually.
             double p = (fps - loFPS) / (hiFPS - loFPS);
             if (p < 0)
                 p = 0;
             if (p > 1)
                 p = 1;
 
             // Plot this data point.
-            SkPoint cur = SkPoint::Make(graphBounds.right() - x, graphBounds.bottom() - p * graphBounds.height());
+            SkPoint cur = SkPoint::Make(graphBounds.left() + x, graphBounds.bottom() - p * graphBounds.height());
             if (path.isEmpty())
                 path.moveTo(cur);
             else
                 path.lineTo(cur);
 
             // Use the fps value to find the right bucket in the histogram.
             int bucketIndex = floor(p * (histogramSize - 1));
 
             // Add the delta time to take the time spent at that fps rate into account.
             histogram[bucketIndex] += delta.InSecondsF();
             maxBucketValue = std::max(histogram[bucketIndex], maxBucketValue);
         }
 
-        x += delta.InSecondsF() * timeScale;
+        x++;
     }
 
     // Draw FPS histogram.
     paint.setColor(SkColorSetRGB(130, 130, 130));
     canvas->drawLine(histogramBounds.left() - 1, histogramBounds.top() - 1, histogramBounds.left() - 1, histogramBounds.bottom() + 1, paint);
     canvas->drawLine(histogramBounds.right() + 1, histogramBounds.top() - 1, histogramBounds.right() + 1, histogramBounds.bottom() + 1, paint);
 
     paint.setColor(SK_ColorRED);
     const double barHeight = histogramBounds.height() / histogramSize;
 
@@ skipping 77 matching lines @@
 
     canvas->restore();
 }
 
 const char* HeadsUpDisplayLayerImpl::layerTypeAsString() const
 {
     return "HeadsUpDisplayLayer";
 }
 
 }  // namespace cc