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 40 matching lines @@
     , m_weakFactoryOnImplThread(ALLOW_THIS_IN_INITIALIZER_LIST(this))
     , m_weakFactory(ALLOW_THIS_IN_INITIALIZER_LIST(this))
     , m_beginFrameCompletionEventOnImplThread(0)
     , m_readbackRequestOnImplThread(0)
     , m_commitCompletionEventOnImplThread(0)
     , m_completionEventForCommitHeldOnTreeActivation(0)
     , m_textureAcquisitionCompletionEventOnImplThread(0)
     , m_nextFrameIsNewlyCommittedFrameOnImplThread(false)
     , m_renderVSyncEnabled(layerTreeHost->settings().renderVSyncEnabled)
     , m_insideDraw(false)
-    , m_totalCommitCount(0)
     , m_deferCommits(false)
     , m_renewTreePriorityOnImplThreadPending(false)
 {
     TRACE_EVENT0("cc", "ThreadProxy::ThreadProxy");
     DCHECK(IsMainThread());
 }
 
 ThreadProxy::~ThreadProxy()
 {
     TRACE_EVENT0("cc", "ThreadProxy::~ThreadProxy");
@@ skipping 176 matching lines @@
                                              offscreenContextProvider,
                                              &recreateSucceeded,
                                              &capabilities));
     completion.wait();
 
     if (recreateSucceeded)
         m_RendererCapabilitiesMainThreadCopy = capabilities;
     return recreateSucceeded;
 }
 
-void ThreadProxy::GetRenderingStats(RenderingStats* stats)
-{
-    DCHECK(IsMainThread());
-
-    DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
-    CompletionEvent completion;
-    Proxy::ImplThread()->postTask(base::Bind(&ThreadProxy::renderingStatsOnImplThread,
-                                             m_implThreadWeakPtr,  &completion, stats));
-    stats->totalCommitTime = m_totalCommitTime;
-    stats->totalCommitCount = m_totalCommitCount;
-
-    completion.wait();
-}
-
 const RendererCapabilities& ThreadProxy::GetRendererCapabilities() const
 {
     DCHECK(m_rendererInitialized);
     return m_RendererCapabilitiesMainThreadCopy;
 }
 
 void ThreadProxy::SetNeedsAnimate()
 {
     DCHECK(IsMainThread());
     if (m_animateRequested)
@@ skipping 402 matching lines @@
 
     // 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 mainThreadBlocked(this);
 
-        base::TimeTicks startTime = base::TimeTicks::HighResNow();
+        RenderingStatsRecorder* statsRecorder = m_layerTreeHost->renderingStatsRecorder();
+        base::TimeTicks startTime = statsRecorder->StartRecording();
+
         CompletionEvent completion;
         Proxy::ImplThread()->postTask(base::Bind(&ThreadProxy::beginFrameCompleteOnImplThread, m_implThreadWeakPtr, &completion, queue.release(), offscreenContextProvider));
         completion.wait();
-        base::TimeTicks endTime = base::TimeTicks::HighResNow();
 
-        m_totalCommitTime += endTime - startTime;
-        m_totalCommitCount++;
+        base::TimeDelta duration = statsRecorder->EndRecording(startTime);
+        statsRecorder->AddCommit(duration);
     }
 
     m_layerTreeHost->commitComplete();
     m_layerTreeHost->didBeginFrame();
 }
 
 void ThreadProxy::beginFrameCompleteOnImplThread(CompletionEvent* completion, ResourceUpdateQueue* rawQueue, scoped_refptr<cc::ContextProvider> offscreenContextProvider)
 {
     scoped_ptr<ResourceUpdateQueue> queue(rawQueue);
 
@@ skipping 369 matching lines @@
     if (*recreateSucceeded) {
         *capabilities = m_layerTreeHostImpl->rendererCapabilities();
         m_layerTreeHostImpl->resourceProvider()->SetOffscreenContextProvider(offscreenContextProvider);
         m_schedulerOnImplThread->didRecreateOutputSurface();
     } else if (offscreenContextProvider) {
         offscreenContextProvider->VerifyContexts();
     }
     completion->signal();
 }
 
-void ThreadProxy::renderingStatsOnImplThread(CompletionEvent* completion, RenderingStats* stats)
-{
-    DCHECK(IsImplThread());
-    m_layerTreeHostImpl->renderingStats(stats);
-    completion->signal();
-}
-
 ThreadProxy::BeginFrameAndCommitState::BeginFrameAndCommitState()
     : memoryAllocationLimitBytes(0)
 {
 }
 
 ThreadProxy::BeginFrameAndCommitState::~BeginFrameAndCommitState()
 {
 }
 
 scoped_ptr<base::Value> ThreadProxy::AsValue() const
@@ skipping 121 matching lines @@
 
 void ThreadProxy::renewTreePriorityOnImplThread()
 {
     DCHECK(m_renewTreePriorityOnImplThreadPending);
     m_renewTreePriorityOnImplThreadPending = false;
 
     renewTreePriority();
 }
 
 }  // namespace cc