cc:: Add RenderingStatsInstrumentation to manage collection of RenderingStats

cc/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/thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "cc/context_provider.h"
@@ skipping 42 matching lines @@
       weak_factory_on_impl_thread_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       begin_frame_completion_event_on_impl_thread_(NULL),
       readback_request_on_impl_thread_(NULL),
       commit_completion_event_on_impl_thread_(NULL),
       completion_event_for_commit_held_on_tree_activation_(NULL),
       texture_acquisition_completion_event_on_impl_thread_(NULL),
       next_frame_is_newly_committed_frame_on_impl_thread_(false),
       render_vsync_enabled_(layer_tree_host->settings().renderVSyncEnabled),
       inside_draw_(false),
-      total_commit_count_(0),
       defer_commits_(false),
       renew_tree_priority_on_impl_thread_pending_(false) {
   TRACE_EVENT0("cc", "ThreadProxy::ThreadProxy");
   DCHECK(IsMainThread());
 }
 
 ThreadProxy::~ThreadProxy() {
   TRACE_EVENT0("cc", "ThreadProxy::~ThreadProxy");
   DCHECK(IsMainThread());
   DCHECK(!started_);
@@ skipping 197 matching lines @@
                  offscreen_context_provider,
                  &recreate_succeeded,
                  &capabilities));
   completion.wait();
 
   if (recreate_succeeded)
     renderer_capabilities_main_thread_copy_ = capabilities;
   return recreate_succeeded;
 }
 
-void ThreadProxy::CollectRenderingStats(RenderingStats* stats) {
-  DCHECK(IsMainThread());
-
-  DebugScopedSetMainThreadBlocked main_thread_blocked(this);
-  CompletionEvent completion;
-  Proxy::ImplThread()->postTask(
-      base::Bind(&ThreadProxy::RenderingStatsOnImplThread,
-                 impl_thread_weak_ptr_,
-                 &completion,
-                 stats));
-  stats->totalCommitTime = total_commit_time_;
-  stats->totalCommitCount = total_commit_count_;
-
-  completion.wait();
-}
-
 const RendererCapabilities& ThreadProxy::GetRendererCapabilities() const {
   DCHECK(renderer_initialized_);
   return renderer_capabilities_main_thread_copy_;
 }
 
 void ThreadProxy::SetNeedsAnimate() {
   DCHECK(IsMainThread());
   if (animate_requested_)
     return;
 
@@ skipping 429 matching lines @@
       offscreen_context_provider = NULL;
   }
 
   // Notify the impl thread that the beginFrame has completed. This will
   // begin the commit process, which is blocking from the main thread's
   // point of view, but asynchronously performed on the impl thread,
   // coordinated by the Scheduler.
   {
     TRACE_EVENT0("cc", "commit");
 
-    DebugScopedSetMainThreadBlocked main_thread_blocked(this);
+    DebugScopedSetMainThreadBlocked main_thread_blocked(this); 
 
-    base::TimeTicks start_time = base::TimeTicks::HighResNow();
+    RenderingStatsInstrumentation* stats_instrumentation =
+        layer_tree_host_->rendering_stats_instrumentation();
+    base::TimeTicks start_time = stats_instrumentation->StartRecording();
+
     CompletionEvent completion;
     Proxy::ImplThread()->postTask(
         base::Bind(&ThreadProxy::BeginFrameCompleteOnImplThread,
                    impl_thread_weak_ptr_,
                    &completion,
                    queue.release(),
                    offscreen_context_provider));
     completion.wait();
 
-    base::TimeTicks end_time = base::TimeTicks::HighResNow();
-    total_commit_time_ += end_time - start_time;
-    total_commit_count_++;
+    base::TimeDelta duration = stats_instrumentation->EndRecording(start_time);
+    stats_instrumentation->AddCommit(duration);
   }
 
   layer_tree_host_->CommitComplete();
   layer_tree_host_->DidBeginFrame();
 }
 
 void ThreadProxy::BeginFrameCompleteOnImplThread(
     CompletionEvent* completion,
     ResourceUpdateQueue* raw_queue,
     scoped_refptr<cc::ContextProvider> offscreen_context_provider) {
@@ skipping 400 matching lines @@
     *capabilities = layer_tree_host_impl_->GetRendererCapabilities();
     layer_tree_host_impl_->resource_provider()->
         SetOffscreenContextProvider(offscreen_context_provider);
     scheduler_on_impl_thread_->didRecreateOutputSurface();
   } else if (offscreen_context_provider) {
     offscreen_context_provider->VerifyContexts();
   }
   completion->signal();
 }
 
-void ThreadProxy::RenderingStatsOnImplThread(CompletionEvent* completion,
-                                             RenderingStats* stats) {
-  DCHECK(IsImplThread());
-  layer_tree_host_impl_->CollectRenderingStats(stats);
-  completion->signal();
-}
-
 ThreadProxy::BeginFrameAndCommitState::BeginFrameAndCommitState()
     : memory_allocation_limit_bytes(0) {}
 
 ThreadProxy::BeginFrameAndCommitState::~BeginFrameAndCommitState() {}
 
 scoped_ptr<base::Value> ThreadProxy::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
 
   CompletionEvent completion;
   {
@@ skipping 118 matching lines @@
 }
 
 void ThreadProxy::RenewTreePriorityOnImplThread() {
   DCHECK(renew_tree_priority_on_impl_thread_pending_);
   renew_tree_priority_on_impl_thread_pending_ = false;
 
   RenewTreePriority();
 }
 
 }  // namespace cc