cc: add RingBuffer class for timestamp storing in FrameRateCounter

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 160 matching lines @@
         drawDebugRects(canvas, layerTreeImpl()->debug_rect_history());
 }
 
 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 = fpsCounter->timeStampHistorySize() - 3;
+    const int graphWidth = fpsCounter->bufferSize() - 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;
 
     SkPaint paint = createPaint();
 
     // Draw background.
     paint.setColor(SkColorSetARGB(215, 17, 17, 17));
     canvas->drawRect(SkRect::MakeXYWH(left, top, width, height), paint);
 
     SkRect textBounds = SkRect::MakeXYWH(left + padding, top + padding, graphWidth + histogramWidth + gap + 2, fontHeight);
     SkRect graphBounds = SkRect::MakeXYWH(left + padding, textBounds.bottom() + 2 * padding, graphWidth, graphHeight);
     SkRect histogramBounds = SkRect::MakeXYWH(graphBounds.right() + gap, graphBounds.top(), histogramWidth, graphHeight);
 
     drawFPSCounterText(canvas, paint, fpsCounter, textBounds);
     drawFPSCounterGraphAndHistogram(canvas, paint, fpsCounter, graphBounds, histogramBounds);
 
     return top + height;
 }
 
 void HeadsUpDisplayLayerImpl::drawFPSCounterText(SkCanvas* canvas, SkPaint& paint, FrameRateCounter* fpsCounter, SkRect bounds)
 {
     // Update FPS text - not every frame so text is readable
-    if (base::TimeDelta(fpsCounter->timeStampOfRecentFrame(0) - textUpdateTime).InSecondsF() > 0.25) {
+    if (base::TimeDelta(fpsCounter->readBuffer(0) - textUpdateTime).InSecondsF() > 0.25) {

[shawnsingh, 2013/01/09 20:55:09]

Personally, as I'm reading the code here, I would like a more intuitive,
meaningful name than "readBuffer".  I would like to see something that makes it
clear that we're accessing a recent timestamp that has been stored in the
fpsCounter.  Perhaps we could keep the timeStampOfRecentFrame() and
timeStampHistorySize() functions the same, and just make them trivial inlined
wrappers to use the ring buffer?

That may also make it possible for fpsCounter to own an instance of RingBuffer,
rather than to inherit it.  I don't feel too strongly either way, but in my
opinion, the owning concept makes more sense - i.e.  "fpsCounter uses a
RingBuffer" , not  "fpsCounter is a RingBuffer".

         m_averageFPS = fpsCounter->getAverageFPS();
-        textUpdateTime = fpsCounter->timeStampOfRecentFrame(0);
+        textUpdateTime = fpsCounter->readBuffer(0);
     }
 
     // Draw FPS text.
     if (m_fontAtlas.get()) {
         std::string fpsText = base::StringPrintf("FPS:%5.1f", m_averageFPS);
         std::string minMaxText = base::StringPrintf("%.0f-%.0f", std::min( m_minFPS, m_maxFPS), m_maxFPS);
 
         int minMaxWidth = m_fontAtlas->textSize(minMaxText).width();
         gfx::Size textArea(bounds.width(), bounds.height());
 
@@ skipping 22 matching lines @@
     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 = 1; i < fpsCounter->timeStampHistorySize() - 1; ++i) {
-        base::TimeDelta delta = fpsCounter->timeStampOfRecentFrame(i + 1) - fpsCounter->timeStampOfRecentFrame(i);
+    for (int i = 1; i < fpsCounter->bufferSize() - 1; ++i) {
+        base::TimeDelta delta = fpsCounter->readBuffer(i + 1) - fpsCounter->readBuffer(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.
@@ skipping 109 matching lines @@
 
     canvas->restore();
 }
 
 const char* HeadsUpDisplayLayerImpl::layerTypeAsString() const
 {
     return "HeadsUpDisplayLayer";
 }
 
 }  // namespace cc