cc:: Add RenderingStatsInstrumentation to manage collection of RenderingStats

cc/rendering_stats_recorder.cc

Index: cc/rendering_stats_recorder.cc
diff --git a/cc/rendering_stats_recorder.cc b/cc/rendering_stats_recorder.cc
new file mode 100644
index 0000000000000000000000000000000000000000..417c19dd1a54ea052c77cc518856b839135fea62
--- /dev/null
+++ b/cc/rendering_stats_recorder.cc
@@ -0,0 +1,162 @@
+// Copyright 2013 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/rendering_stats_recorder.h"
+
+namespace cc {
+
+// static
+scoped_ptr<RenderingStatsRecorder> RenderingStatsRecorder::create() {

[danakj, 2013/03/13 17:25:41]

Create()

[egraether, 2013/03/14 18:58:07]

Done.

+  return make_scoped_ptr(new RenderingStatsRecorder());
+}
+
+RenderingStatsRecorder::RenderingStatsRecorder()
+    : record_rendering_stats_(false) {
+}
+
+RenderingStats RenderingStatsRecorder::GetRenderingStats() {
+  base::AutoLock scoped_lock(lock_);
+  return rendering_stats_;
+}
+
+bool RenderingStatsRecorder::record_rendering_stats() const {
+  return record_rendering_stats_;

[danakj, 2013/03/13 17:25:41]

why no lock?

+}
+
+void RenderingStatsRecorder::set_record_rendering_stats(
+    bool record_rendering_stats) {
+  record_rendering_stats_ = record_rendering_stats;

[danakj, 2013/03/13 17:25:41]

autolock here

+}
+
+base::TimeTicks RenderingStatsRecorder::StartRecording() const {
+  if (record_rendering_stats_)

[danakj, 2013/03/13 17:25:41]

autolock here

+    return base::TimeTicks::HighResNow();
+  return base::TimeTicks();
+}
+
+base::TimeDelta RenderingStatsRecorder::EndRecording(
+    base::TimeTicks start_time) const {
+  if (!start_time.is_null())
+    return base::TimeTicks::HighResNow() - start_time;
+  return base::TimeDelta();
+}
+
+void RenderingStatsRecorder::AddStats(const RenderingStats& other) {
+  if (!record_rendering_stats_)

[danakj, 2013/03/13 17:25:41]

move the lock to the top of these functions, so you lock access to the flag too.

+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.Add(other);
+}
+
+void RenderingStatsRecorder::IncrementAnimationFrameCount() {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.numAnimationFrames++;
+}
+
+void RenderingStatsRecorder::SetScreenAndDroppedFrameCount(
+    int64 screen_total,
+    int64 dropped_total) {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.numFramesSentToScreen = screen_total;
+  rendering_stats_.droppedFrameCount = dropped_total;
+}
+
+void RenderingStatsRecorder::AddCommit(base::TimeDelta duration) {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.totalCommitTime += duration;
+  rendering_stats_.totalCommitCount++;
+}
+
+void RenderingStatsRecorder::AddPaint(base::TimeDelta duration, int64 pixels) {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.totalPaintTime += duration;
+  rendering_stats_.totalPixelsPainted += pixels;
+}
+
+void RenderingStatsRecorder::AddRaster(base::TimeDelta duration,
+                                       int64 pixels,
+                                       bool is_in_pending_tree_now_bin) {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.totalRasterizeTime += duration;
+  rendering_stats_.totalPixelsRasterized += pixels;
+
+  if (is_in_pending_tree_now_bin)
+    rendering_stats_.totalRasterizeTimeForNowBinsOnPendingTree += duration;
+}
+
+void RenderingStatsRecorder::IncrementImplThreadScrolls() {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.numImplThreadScrolls++;
+}
+
+void RenderingStatsRecorder::IncrementMainThreadScrolls() {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.numMainThreadScrolls++;
+}
+
+void RenderingStatsRecorder::AddLayersDrawn(int64 amount) {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.numLayersDrawn += amount;
+}
+
+void RenderingStatsRecorder::AddMissingTiles(int64 amount) {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.numMissingTiles += amount;
+}
+
+void RenderingStatsRecorder::AddDeferredImageDecode(base::TimeDelta duration) {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.totalDeferredImageDecodeTime += duration;
+  rendering_stats_.totalDeferredImageDecodeCount++;
+}
+
+void RenderingStatsRecorder::AddImageGathering(base::TimeDelta duration) {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.totalImageGatheringTime += duration;
+  rendering_stats_.totalImageGatheringCount++;
+}
+
+void RenderingStatsRecorder::IncrementDeferredImageCacheHitCount() {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.totalDeferredImageCacheHitCount++;
+}
+
+}  // namespace cc