Add average commit time to perf tests.

cc/CCThreadProxy.cpp

 // 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 "config.h"
 
 #include "CCThreadProxy.h"
 
 #include "CCDelayBasedTimeSource.h"
 #include "CCDrawQuad.h"
@@ skipping 36 matching lines @@
     , m_texturesAcquired(true)
     , m_inCompositeAndReadback(false)
     , m_mainThreadProxy(CCScopedThreadProxy::create(CCProxy::mainThread()))
     , m_beginFrameCompletionEventOnImplThread(0)
     , m_readbackRequestOnImplThread(0)
     , m_commitCompletionEventOnImplThread(0)
     , m_textureAcquisitionCompletionEventOnImplThread(0)
     , m_resetContentsTexturesPurgedAfterCommitOnImplThread(false)
     , m_nextFrameIsNewlyCommittedFrameOnImplThread(false)
     , m_renderVSyncEnabled(layerTreeHost->settings().renderVSyncEnabled)
+    , m_totalCommitCount(0)
 {
     TRACE_EVENT0("cc", "CCThreadProxy::CCThreadProxy");
     ASSERT(isMainThread());
 }
 
 CCThreadProxy::~CCThreadProxy()
 {
     TRACE_EVENT0("cc", "CCThreadProxy::~CCThreadProxy");
     ASSERT(isMainThread());
     ASSERT(!m_started);
@@ skipping 167 matching lines @@
                                                        context.leakPtr(),
                                                        &recreateSucceeded,
                                                        &capabilities));
     completion.wait();
 
     if (recreateSucceeded)
         m_RendererCapabilitiesMainThreadCopy = capabilities;
     return recreateSucceeded;
 }
 
-void CCThreadProxy::implSideRenderingStats(CCRenderingStats& stats)
+void CCThreadProxy::renderingStats(CCRenderingStats* stats)
 {
     ASSERT(isMainThread());
 
     DebugScopedSetMainThreadBlocked mainThreadBlocked;
     CCCompletionEvent completion;
-    CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::implSideRenderingStatsOnImplThread,
+    CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::renderingStatsOnImplThread,
                                                        &completion,
-                                                       &stats));
+                                                       stats));
+    stats->totalCommitTimeInSeconds = m_totalCommitTime.InSecondsF();
+    stats->totalCommitCount = m_totalCommitCount;
+
     completion.wait();
 }
 
 const RendererCapabilities& CCThreadProxy::rendererCapabilities() const
 {
     ASSERT(m_rendererInitialized);
     return m_RendererCapabilitiesMainThreadCopy;
 }
 
 void CCThreadProxy::loseContext()
@@ skipping 289 matching lines @@
         m_animateRequested = false;
         setNeedsAnimate();
     }
 
     // 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 CCScheduler.
     {
         TRACE_EVENT0("cc", "commit");
+
         DebugScopedSetMainThreadBlocked mainThreadBlocked;
 
+        base::TimeTicks startTime = base::TimeTicks::HighResNow();
         CCCompletionEvent completion;
         CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::beginFrameCompleteOnImplThread, &completion, queue.release()));
         completion.wait();
+        base::TimeTicks endTime = base::TimeTicks::HighResNow();
+
+        m_totalCommitTime += endTime - startTime;
+        m_totalCommitCount++;
     }
 
     m_layerTreeHost->commitComplete();
     m_layerTreeHost->didBeginFrame();
 }
 
 void CCThreadProxy::beginFrameCompleteOnImplThread(CCCompletionEvent* completion, PassOwnPtr<CCTextureUpdateQueue> queue)
 {
     TRACE_EVENT0("cc", "CCThreadProxy::beginFrameCompleteOnImplThread");
     ASSERT(!m_commitCompletionEventOnImplThread);
@@ skipping 338 matching lines @@
     ASSERT(isImplThread());
     m_layerTreeHost->deleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
     *recreateSucceeded = m_layerTreeHostImpl->initializeRenderer(adoptPtr(contextPtr));
     if (*recreateSucceeded) {
         *capabilities = m_layerTreeHostImpl->rendererCapabilities();
         m_schedulerOnImplThread->didRecreateContext();
     }
     completion->signal();
 }
 
-void CCThreadProxy::implSideRenderingStatsOnImplThread(CCCompletionEvent* completion, CCRenderingStats* stats)
+void CCThreadProxy::renderingStatsOnImplThread(CCCompletionEvent* completion, CCRenderingStats* stats)
 {
     ASSERT(isImplThread());
-    m_layerTreeHostImpl->renderingStats(*stats);
+    m_layerTreeHostImpl->renderingStats(stats);
     completion->signal();
 }
 
 CCThreadProxy::BeginFrameAndCommitState::BeginFrameAndCommitState()
     : monotonicFrameBeginTime(0)
 {
 }
 
 CCThreadProxy::BeginFrameAndCommitState::~BeginFrameAndCommitState()
 {
 }
 
 } // namespace cc