cc: add rasterize time to continuous painting graph data in impl-side-painting

cc/paint_time_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 "cc/paint_time_counter.h"
 
 namespace cc {
 
 // static
 scoped_ptr<PaintTimeCounter> PaintTimeCounter::create() {
   return make_scoped_ptr(new PaintTimeCounter());
 }
 
-PaintTimeCounter::PaintTimeCounter() {
+PaintTimeCounter::PaintTimeCounter()
+  : ignore_next_paint_time_(true),
+    ignore_next_rasterize_time_(true) {
 }
 
 base::TimeDelta PaintTimeCounter::GetPaintTimeOfRecentFrame(
     const size_t& n) const {
   DCHECK(n < ring_buffer_.BufferSize());
 
   if (ring_buffer_.IsFilledIndex(n))
-    return ring_buffer_.ReadBuffer(n);
+    return ring_buffer_.ReadBuffer(n).time();
 
   return base::TimeDelta();
 }
 
-void PaintTimeCounter::SavePaintTime(const base::TimeDelta& total_paint_time) {
-  base::TimeDelta paint_time = total_paint_time - last_total_paint_time_;
-
-  if (paint_time.InMillisecondsF() > 0)
-    ring_buffer_.SaveToBuffer(paint_time);
+void PaintTimeCounter::SavePaintTime(const base::TimeDelta& total_paint_time,
+                                     const int& frame_number) {
+  if (!ignore_next_paint_time_)
+    GetEntryForFrame(frame_number).paint_time =
+        total_paint_time - last_total_paint_time_;
 
   last_total_paint_time_ = total_paint_time;
+  ignore_next_paint_time_ = false;
+}
+
+void PaintTimeCounter::SaveRasterizeTime(
+    const base::TimeDelta& total_rasterize_time,
+    const int& frame_number) {
+  if (!ignore_next_rasterize_time_)

[nduca, 2013/02/13 08:12:21]

since this is just for the first entry in the ring buffer, what about just
saying if (num entries in ring buffer  == 1)?

+    GetEntryForFrame(frame_number).rasterize_time =

[nduca, 2013/02/13 08:12:21]

Oh, i just realized....

So! The sequence in walltime is

commit
   painting happens for pending now bins
   didActivateTree

if you save the paintNowBin times at didActivateTree, then you actually are
done. All the now-bin painting has completed and you have the correct number...

Ping me when you're in tomorrow if this doesn't make sense.

+        total_rasterize_time - last_total_rasterize_time_;
+
+  last_total_rasterize_time_ = total_rasterize_time;
+  ignore_next_rasterize_time_ = false;
 }
 
 void PaintTimeCounter::GetMinAndMaxPaintTime(base::TimeDelta* min,
                                              base::TimeDelta* max) const {
   *min = base::TimeDelta::FromDays(1);
   *max = base::TimeDelta();
 
   for (size_t i = 0; i < ring_buffer_.BufferSize(); i++) {
     if (ring_buffer_.IsFilledIndex(i)) {
-      base::TimeDelta paint_time = ring_buffer_.ReadBuffer(i);
+      base::TimeDelta paint_time = ring_buffer_.ReadBuffer(i).time();
 
       if (paint_time < *min)
         *min = paint_time;
       if (paint_time > *max)
         *max = paint_time;
     }
   }
 
   if (*min > *max)
     *min = *max;
 }
 
+void PaintTimeCounter::ClearHistory() {
+  ring_buffer_.Clear();
+  ignore_next_paint_time_ = true;
+  ignore_next_rasterize_time_ = true;
+}
+
+PaintTimeCounter::Entry& PaintTimeCounter::GetEntryForFrame(

[nduca, 2013/02/13 08:12:21]

GetOrCreateEntryForFrame since it adds it if it doesn't exist?

+    const int& frame_number) {
+  for (size_t i = 0; i < ring_buffer_.BufferSize(); i++) {
+    if (ring_buffer_.IsFilledIndex(i) &&

[egraether, 2013/02/12 00:15:30]

Buffer iteration is a mess. I will try to implement a simple iterator class.

+        ring_buffer_.ReadBuffer(i).frame_number == frame_number)
+      return ring_buffer_.MutableReadBuffer(i);
+  }
+
+  Entry entry;
+  entry.frame_number = frame_number;
+  ring_buffer_.SaveToBuffer(entry);
+  return ring_buffer_.MutableReadBuffer(ring_buffer_.BufferSize() - 1);
+}
+
 }  // namespace cc