cc:: Add RenderingStatsInstrumentation to manage collection of RenderingStats

cc/trees/single_thread_proxy.cc

 // Copyright 2011 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/trees/single_thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "cc/base/thread.h"
 #include "cc/output/context_provider.h"
@@ skipping 153 matching lines @@
       offscreen_context_provider->VerifyContexts();
     }
   }
 
   if (initialized)
     output_surface_lost_ = false;
 
   return initialized;
 }
 
-void SingleThreadProxy::CollectRenderingStats(RenderingStats* stats) {
-  stats->totalCommitTime = total_commit_time_;
-  stats->totalCommitCount = total_commit_count_;
-  layer_tree_host_impl_->CollectRenderingStats(stats);
-}
-
 const RendererCapabilities& SingleThreadProxy::GetRendererCapabilities() const {
   DCHECK(renderer_initialized_);
   // Note: this gets called during the commit by the "impl" thread.
   return renderer_capabilities_for_main_thread_;
 }
 
 void SingleThreadProxy::SetNeedsAnimate() {
   // Thread-only feature.
   NOTREACHED();
 }
 
 void SingleThreadProxy::DoCommit(scoped_ptr<ResourceUpdateQueue> queue) {
   DCHECK(Proxy::IsMainThread());
   // Commit immediately.
   {
     DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
     DebugScopedSetImplThread impl(this);
 
-    base::TimeTicks startTime = base::TimeTicks::HighResNow();
+    RenderingStatsInstrumentation* stats_instrumentation =
+        layer_tree_host_->rendering_stats_instrumentation();
+    base::TimeTicks startTime = stats_instrumentation->StartRecording();
+
     layer_tree_host_impl_->BeginCommit();
 
     layer_tree_host_->contents_texture_manager()->
         PushTexturePrioritiesToBackings();
     layer_tree_host_->BeginCommitOnImplThread(layer_tree_host_impl_.get());
 
     scoped_ptr<ResourceUpdateController> updateController =
         ResourceUpdateController::Create(
             NULL,
             Proxy::MainThread(),
             queue.Pass(),
             layer_tree_host_impl_->resource_provider());
     updateController->Finalize();
 
     layer_tree_host_->FinishCommitOnImplThread(layer_tree_host_impl_.get());
 
     layer_tree_host_impl_->CommitComplete();
 
 #ifndef NDEBUG
     // In the single-threaded case, the scroll deltas should never be
     // touched on the impl layer tree.
     scoped_ptr<ScrollAndScaleSet> scrollInfo =
         layer_tree_host_impl_->ProcessScrollDeltas();
     DCHECK(!scrollInfo->scrolls.size());
 #endif
 
-    base::TimeTicks endTime = base::TimeTicks::HighResNow();
-    total_commit_time_ += endTime - startTime;
-    total_commit_count_++;
+    base::TimeDelta duration = stats_instrumentation->EndRecording(startTime);
+    stats_instrumentation->AddCommit(duration);
   }
   layer_tree_host_->CommitComplete();
   next_frame_is_newly_committed_frame_ = true;
 }
 
 void SingleThreadProxy::SetNeedsCommit() {
   DCHECK(Proxy::IsMainThread());
   layer_tree_host_->ScheduleComposite();
 }
 
@@ skipping 212 matching lines @@
 
 bool SingleThreadProxy::CommitPendingForTesting() { return false; }
 
 skia::RefPtr<SkPicture> SingleThreadProxy::CapturePicture() {
   // Impl-side painting only.
   NOTREACHED();
   return skia::RefPtr<SkPicture>();
 }
 
 }  // namespace cc