cc:: Add RenderingStatsInstrumentation to manage collection of RenderingStats

cc/layer_tree_host.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/layer_tree_host.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
@@ skipping 57 matching lines @@
         return scoped_ptr<LayerTreeHost>();
     return layerTreeHost.Pass();
 }
 
 LayerTreeHost::LayerTreeHost(LayerTreeHostClient* client, const LayerTreeSettings& settings)
     : m_animating(false)
     , m_needsFullTreeSync(true)
     , m_needsFilterContext(false)
     , m_client(client)
     , m_commitNumber(0)
-    , m_renderingStats()
+    , m_renderingStatsRecorder(RenderingStatsRecorder::create())
     , m_rendererInitialized(false)
     , m_outputSurfaceLost(false)
     , m_numFailedRecreateAttempts(0)
     , m_settings(settings)
     , m_debugState(settings.initialDebugState)
     , m_deviceScaleFactor(1)
     , m_visible(true)
     , m_pageScaleFactor(1)
     , m_minPageScaleFactor(1)
     , m_maxPageScaleFactor(1)
     , m_triggerIdleUpdates(true)
     , m_backgroundColor(SK_ColorWHITE)
     , m_hasTransparentBackground(false)
     , m_partialTextureUpdateRequests(0)
 {
     if (m_settings.acceleratedAnimationEnabled)
         m_animationRegistrar = AnimationRegistrar::create();
     numLayerTreeInstances++;
+    m_renderingStatsRecorder->set_record_rendering_stats(m_debugState.recordRenderingStats());
 }
 
 bool LayerTreeHost::initialize(scoped_ptr<Thread> implThread)
 {
     if (implThread)
         return initializeProxy(ThreadProxy::create(this, implThread.Pass()));
     else
         return initializeProxy(SingleThreadProxy::Create(this));
 }
 
@@ skipping 115 matching lines @@
     m_client->didBeginFrame();
 }
 
 void LayerTreeHost::updateAnimations(base::TimeTicks frameBeginTime)
 {
     m_animating = true;
     m_client->animate((frameBeginTime - base::TimeTicks()).InSecondsF());
     animateLayers(frameBeginTime);
     m_animating = false;
 
-    m_renderingStats.numAnimationFrames++;
+    m_renderingStatsRecorder->IncrementAnimationFrameCount();
 }
 
 void LayerTreeHost::didStopFlinging()
 {
   m_proxy->MainThreadHasStoppedFlinging();
 }
 
 void LayerTreeHost::layout()
 {
     m_client->layout();
@@ skipping 84 matching lines @@
             syncTree->ResetContentsTexturesPurged();
     }
 
     if (!m_settings.implSidePainting) {
         // If we're not in impl-side painting, the tree is immediately
         // considered active.
         syncTree->DidBecomeActive();
     }
 
     if (m_debugState.continuousPainting)
-        hostImpl->savePaintTime(m_renderingStats.totalPaintTime, commitNumber());
+        hostImpl->savePaintTime(m_renderingStatsRecorder->GetRenderingStats().totalPaintTime, commitNumber());
 
     m_commitNumber++;
 }
 
 void LayerTreeHost::willCommit()
 {
     m_client->willCommit();
 }
 
 void LayerTreeHost::updateHudLayer()
@@ skipping 21 matching lines @@
 }
 
 scoped_ptr<InputHandler> LayerTreeHost::createInputHandler()
 {
     return m_client->createInputHandler();
 }
 
 scoped_ptr<LayerTreeHostImpl> LayerTreeHost::createLayerTreeHostImpl(LayerTreeHostImplClient* client)
 {
     DCHECK(m_proxy->IsImplThread());
-    scoped_ptr<LayerTreeHostImpl> hostImpl(LayerTreeHostImpl::create(m_settings, client, m_proxy.get()));
+    scoped_ptr<LayerTreeHostImpl> hostImpl(LayerTreeHostImpl::create(m_settings, client, m_proxy.get(), m_renderingStatsRecorder.get()));
     if (m_settings.calculateTopControlsPosition && hostImpl->topControlsManager())
         m_topControlsManagerWeakPtr = hostImpl->topControlsManager()->AsWeakPtr();
     return hostImpl.Pass();
 }
 
 void LayerTreeHost::didLoseOutputSurface()
 {
     TRACE_EVENT0("cc", "LayerTreeHost::didLoseOutputSurface");
     DCHECK(m_proxy->IsMainThread());
     m_outputSurfaceLost = true;
@@ skipping 21 matching lines @@
     m_proxy->SetDeferCommits(deferCommits);
 }
 
 void LayerTreeHost::didDeferCommit()
 {
 }
 
 void LayerTreeHost::renderingStats(RenderingStats* stats) const
 {
     CHECK(m_debugState.recordRenderingStats());
-    *stats = m_renderingStats;
-    m_proxy->GetRenderingStats(stats);
+    *stats = m_renderingStatsRecorder->GetRenderingStats();
+}
+
+RenderingStatsRecorder* LayerTreeHost::renderingStatsRecorder() const

[danakj, 2013/03/13 17:25:41]

rename rendering_stats_recorder()

[egraether, 2013/03/14 18:58:07]

Done.

+{
+    return m_renderingStatsRecorder.get();

[danakj, 2013/03/13 17:25:41]

move this function to the header

[egraether, 2013/03/14 18:58:07]

Done.

 }
 
 const RendererCapabilities& LayerTreeHost::rendererCapabilities() const
 {
     return m_proxy->GetRendererCapabilities();
 }
 
 void LayerTreeHost::setNeedsAnimate()
 {
     DCHECK(m_proxy->HasImplThread());
@@ skipping 51 matching lines @@
 }
 
 void LayerTreeHost::setDebugState(const LayerTreeDebugState& debugState)
 {
     LayerTreeDebugState newDebugState = LayerTreeDebugState::unite(m_settings.initialDebugState, debugState);
 
     if (LayerTreeDebugState::equal(m_debugState, newDebugState))
         return;
 
     m_debugState = newDebugState;
+    m_renderingStatsRecorder->set_record_rendering_stats(m_debugState.recordRenderingStats());
     setNeedsCommit();
 }
 
 void LayerTreeHost::setViewportSize(const gfx::Size& layoutViewportSize, const gfx::Size& deviceViewportSize)
 {
     if (layoutViewportSize == m_layoutViewportSize && deviceViewportSize == m_deviceViewportSize)
         return;
 
     m_layoutViewportSize = layoutViewportSize;
     m_deviceViewportSize = deviceViewportSize;
@@ skipping 191 matching lines @@
             continue;
 
         if (bytes > maxBackgroundTextureBytes)
             maxBackgroundTextureBytes = bytes;
         if (!readbackBytes)
             readbackBytes = Resource::MemorySizeBytes(m_deviceViewportSize, GL_RGBA);
     }
     return readbackBytes + maxBackgroundTextureBytes + contentsTextureBytes;
 }
 
-bool LayerTreeHost::paintMasksForRenderSurface(Layer* renderSurfaceLayer, ResourceUpdateQueue& queue)
+bool LayerTreeHost::paintMasksForRenderSurface(Layer* renderSurfaceLayer, ResourceUpdateQueue& queue, RenderingStats* stats)
 {
     // Note: Masks and replicas only exist for layers that own render surfaces. If we reach this point
     // in code, we already know that at least something will be drawn into this render surface, so the
     // mask and replica should be painted.
 
-    RenderingStats* stats = m_debugState.recordRenderingStats() ? &m_renderingStats : NULL;
-
     bool needMoreUpdates = false;
     Layer* maskLayer = renderSurfaceLayer->mask_layer();
     if (maskLayer) {
         maskLayer->Update(&queue, 0, stats);
         needMoreUpdates |= maskLayer->NeedMoreUpdates();
     }
 
     Layer* replicaMaskLayer = renderSurfaceLayer->replica_layer() ? renderSurfaceLayer->replica_layer()->mask_layer() : 0;
     if (replicaMaskLayer) {
         replicaMaskLayer->Update(&queue, 0, stats);
         needMoreUpdates |= replicaMaskLayer->NeedMoreUpdates();
     }
     return needMoreUpdates;
 }
 
 bool LayerTreeHost::paintLayerContents(const LayerList& renderSurfaceLayerList, ResourceUpdateQueue& queue)
 {
     // Use FrontToBack to allow for testing occlusion and performing culling during the tree walk.
     typedef LayerIterator<Layer, LayerList, RenderSurface, LayerIteratorActions::FrontToBack> LayerIteratorType;
 
     bool needMoreUpdates = false;
     bool recordMetricsForFrame = m_settings.showOverdrawInTracing && base::debug::TraceLog::GetInstance() && base::debug::TraceLog::GetInstance()->IsEnabled();
     OcclusionTracker occlusionTracker(m_rootLayer->render_surface()->content_rect(), recordMetricsForFrame);
     occlusionTracker.set_minimum_tracking_size(m_settings.minimumOcclusionTrackingSize);
 
     prioritizeTextures(renderSurfaceLayerList, occlusionTracker.OverdrawMetrics());
 
-    RenderingStats* stats = m_debugState.recordRenderingStats() ? &m_renderingStats : NULL;
+    // TODO: Switch Layer::update() to use RenderingStatsRecorder

[danakj, 2013/03/13 17:25:41]

stick you ldap in brackets after the TODO - ie TODO(egraether):

[egraether, 2013/03/14 18:58:07]

Done.

+    RenderingStats stats;
+    RenderingStats* statsPtr = m_debugState.recordRenderingStats() ? &stats : NULL;
 
     LayerIteratorType end = LayerIteratorType::end(&renderSurfaceLayerList);
     for (LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList); it != end; ++it) {
         occlusionTracker.EnterLayer(it);
 
         if (it.representsTargetRenderSurface()) {
             DCHECK(it->render_surface()->draw_opacity() || it->render_surface()->draw_opacity_is_animating());
-            needMoreUpdates |= paintMasksForRenderSurface(*it, queue);
+            needMoreUpdates |= paintMasksForRenderSurface(*it, queue, statsPtr);
         } else if (it.representsItself()) {
             DCHECK(!it->bounds().IsEmpty());
-            it->Update(&queue, &occlusionTracker, stats);
+            it->Update(&queue, &occlusionTracker, statsPtr);
             needMoreUpdates |= it->NeedMoreUpdates();
         }
 
         occlusionTracker.LeaveLayer(it);
     }
 
+    m_renderingStatsRecorder->AddStats(stats);
+
     occlusionTracker.OverdrawMetrics().RecordMetrics(this);
 
     return needMoreUpdates;
 }
 
 void LayerTreeHost::applyScrollAndScale(const ScrollAndScaleSet& info)
 {
     if (!m_rootLayer)
         return;
 
@@ skipping 142 matching lines @@
     for (size_t childIndex = 0; childIndex < layer->children().size(); ++childIndex)
         setAnimationEventsRecursive(events, layer->children()[childIndex].get(), wallClockTime);
 }
 
 skia::RefPtr<SkPicture> LayerTreeHost::capturePicture()
 {
     return m_proxy->CapturePicture();
 }
 
 }  // namespace cc