cc:: Add RenderingStatsInstrumentation to manage collection of RenderingStats

This change adds the class RenderingStatsInstrumentation that manages conditional
saving and thread-specific access to a private RenderingStats instance.
An instance of RenderingStatsRecorder is created on LayerTreeHost, which
passes references to LayerTreeHostImpl and TileManager. Access to reading
and writing on the internal RenderingStats instance is guarded by a lock.

All rendering stats saving in LayerTreeHost, Single-/ThreadProxy,
LayerTreeHostImpl and TileManager has been switched to use the
RenderingStatsInstrumentation. Stats collection within Layer::update() still
follows the original structure to keep this change small.

BUG=181319
NOTRY=true

Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=189475

Review URL: https://chromiumcodereview.appspot.com/12519006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@189621 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 164 insertions, 0 deletions

diff --git a/cc/debug/rendering_stats_instrumentation.cc b/cc/debug/rendering_stats_instrumentation.cc
new file mode 100644
index 0000000..1fb5296
--- /dev/null
+++ b/cc/debug/rendering_stats_instrumentation.cc
@@ -0,0 +1,164 @@
+// 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/debug/rendering_stats_instrumentation.h"
+
+namespace cc {
+
+// static
+scoped_ptr<RenderingStatsInstrumentation>
+    RenderingStatsInstrumentation::Create() {
+  return make_scoped_ptr(new RenderingStatsInstrumentation());
+}
+
+RenderingStatsInstrumentation::RenderingStatsInstrumentation()
+    : record_rendering_stats_(false) {
+}
+
+RenderingStatsInstrumentation::~RenderingStatsInstrumentation() {}
+
+RenderingStats RenderingStatsInstrumentation::GetRenderingStats() {
+  base::AutoLock scoped_lock(lock_);
+  return rendering_stats_;
+}
+
+base::TimeTicks RenderingStatsInstrumentation::StartRecording() const {
+  if (record_rendering_stats_)
+    return base::TimeTicks::HighResNow();
+  return base::TimeTicks();
+}
+
+base::TimeDelta RenderingStatsInstrumentation::EndRecording(
+    base::TimeTicks start_time) const {
+  if (!start_time.is_null())
+    return base::TimeTicks::HighResNow() - start_time;
+  return base::TimeDelta();
+}
+
+void RenderingStatsInstrumentation::AddStats(const RenderingStats& other) {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.Add(other);
+}
+
+void RenderingStatsInstrumentation::IncrementAnimationFrameCount() {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.numAnimationFrames++;
+}
+
+void RenderingStatsInstrumentation::SetScreenFrameCount(int64 count) {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.numFramesSentToScreen = count;
+}
+
+void RenderingStatsInstrumentation::SetDroppedFrameCount(int64 count) {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.droppedFrameCount = count;
+}
+
+void RenderingStatsInstrumentation::AddCommit(base::TimeDelta duration) {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.totalCommitTime += duration;
+  rendering_stats_.totalCommitCount++;
+}
+
+void RenderingStatsInstrumentation::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 RenderingStatsInstrumentation::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 RenderingStatsInstrumentation::IncrementImplThreadScrolls() {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.numImplThreadScrolls++;
+}
+
+void RenderingStatsInstrumentation::IncrementMainThreadScrolls() {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.numMainThreadScrolls++;
+}
+
+void RenderingStatsInstrumentation::AddLayersDrawn(int64 amount) {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.numLayersDrawn += amount;
+}
+
+void RenderingStatsInstrumentation::AddMissingTiles(int64 amount) {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.numMissingTiles += amount;
+}
+
+void RenderingStatsInstrumentation::AddDeferredImageDecode(
+    base::TimeDelta duration) {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.totalDeferredImageDecodeTime += duration;
+  rendering_stats_.totalDeferredImageDecodeCount++;
+}
+
+void RenderingStatsInstrumentation::AddImageGathering(
+    base::TimeDelta duration) {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.totalImageGatheringTime += duration;
+  rendering_stats_.totalImageGatheringCount++;
+}
+
+void RenderingStatsInstrumentation::IncrementDeferredImageCacheHitCount() {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  rendering_stats_.totalDeferredImageCacheHitCount++;
+}
+
+}  // namespace cc