Add average commit time to perf tests.

cc/CCSingleThreadProxy.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 "CCSingleThreadProxy.h"
 
 #include "CCDrawQuad.h"
 #include "CCGraphicsContext.h"
@@ skipping 10 matching lines @@
 PassOwnPtr<CCProxy> CCSingleThreadProxy::create(CCLayerTreeHost* layerTreeHost)
 {
     return adoptPtr(new CCSingleThreadProxy(layerTreeHost));
 }
 
 CCSingleThreadProxy::CCSingleThreadProxy(CCLayerTreeHost* layerTreeHost)
     : m_layerTreeHost(layerTreeHost)
     , m_contextLost(false)
     , m_rendererInitialized(false)
     , m_nextFrameIsNewlyCommittedFrame(false)
+    , m_totalCommitTime(0)

[nduca, 2012/09/15 00:36:09]

here and elsewhere, add unit. m_totalCommitTimeInSeconds

[brianderson, 2012/09/18 01:16:44]

Done.

+    , m_totalCommitCount(0)
 {
     TRACE_EVENT0("cc", "CCSingleThreadProxy::CCSingleThreadProxy");
     ASSERT(CCProxy::isMainThread());
 }
 
 void CCSingleThreadProxy::start()
 {
     DebugScopedSetImplThread impl;
     m_layerTreeHostImpl = m_layerTreeHost->createLayerTreeHostImpl(this);
 }
@@ skipping 102 matching lines @@
             m_RendererCapabilitiesForMainThread = m_layerTreeHostImpl->rendererCapabilities();
         }
     }
 
     if (initialized)
         m_contextLost = false;
 
     return initialized;
 }
 
-void CCSingleThreadProxy::implSideRenderingStats(CCRenderingStats& stats)
+void CCSingleThreadProxy::renderingStats(CCRenderingStats& stats)
 {
+    stats.totalCommitTimeInSeconds = m_totalCommitTime;
+    stats.totalCommitCount = m_totalCommitCount;
     m_layerTreeHostImpl->renderingStats(stats);
 }
 
 const RendererCapabilities& CCSingleThreadProxy::rendererCapabilities() const
 {
     ASSERT(m_rendererInitialized);
     // Note: this gets called during the commit by the "impl" thread
     return m_RendererCapabilitiesForMainThread;
 }
 
@@ skipping 11 matching lines @@
 }
 
 void CCSingleThreadProxy::doCommit(CCTextureUpdateQueue& queue)
 {
     ASSERT(CCProxy::isMainThread());
     // Commit immediately
     {
         DebugScopedSetMainThreadBlocked mainThreadBlocked;
         DebugScopedSetImplThread impl;
 
+        double startTime = WTF::monotonicallyIncreasingTime();
         m_layerTreeHostImpl->beginCommit();
 
         m_layerTreeHost->beginCommitOnImplThread(m_layerTreeHostImpl.get());
 
         // CCTextureUpdateController::updateTextures is non-blocking and will
         // return without updating any textures if the uploader is busy. This
         // shouldn't be a problem here as the throttled uploader isn't used in
         // single thread mode. For correctness, loop until no more updates are
         // pending.
         while (queue.hasMoreUpdates())
             CCTextureUpdateController::updateTextures(m_layerTreeHostImpl->resourceProvider(), m_layerTreeHostImpl->renderer()->textureCopier(), m_layerTreeHostImpl->renderer()->textureUploader(), &queue, maxPartialTextureUpdates());
 
         m_layerTreeHost->finishCommitOnImplThread(m_layerTreeHostImpl.get());
 
         m_layerTreeHostImpl->commitComplete();
 
 #if !ASSERT_DISABLED
         // In the single-threaded case, the scroll deltas should never be
         // touched on the impl layer tree.
         OwnPtr<CCScrollAndScaleSet> scrollInfo = m_layerTreeHostImpl->processScrollDeltas();
         ASSERT(!scrollInfo->scrolls.size());
 #endif
+
+        double endTime = WTF::monotonicallyIncreasingTime();
+        double commitTime = endTime - startTime;
+        m_totalCommitTime += commitTime;
+        m_totalCommitCount++;
     }
     m_layerTreeHost->commitComplete();
     m_nextFrameIsNewlyCommittedFrame = true;
 }
 
 void CCSingleThreadProxy::setNeedsCommit()
 {
     ASSERT(CCProxy::isMainThread());
     m_layerTreeHost->scheduleComposite();
 }
@@ skipping 115 matching lines @@
 
 void CCSingleThreadProxy::didSwapFrame()
 {
     if (m_nextFrameIsNewlyCommittedFrame) {
         m_nextFrameIsNewlyCommittedFrame = false;
         m_layerTreeHost->didCommitAndDrawFrame();
     }
 }
 
 }