cc:: Add RenderingStatsInstrumentation to manage collection of RenderingStats

cc/layer_tree_host_impl.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_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 119 matching lines @@
 
 LayerTreeHostImpl::FrameData::FrameData()
     : containsIncompleteTile(false)
 {
 }
 
 LayerTreeHostImpl::FrameData::~FrameData()
 {
 }
 
-scoped_ptr<LayerTreeHostImpl> LayerTreeHostImpl::create(const LayerTreeSettings& settings, LayerTreeHostImplClient* client, Proxy* proxy)
+scoped_ptr<LayerTreeHostImpl> LayerTreeHostImpl::create(const LayerTreeSettings& settings, LayerTreeHostImplClient* client, Proxy* proxy, RenderingStatsRecorder* renderingStatsRecorder)
 {
-    return make_scoped_ptr(new LayerTreeHostImpl(settings, client, proxy));
+    return make_scoped_ptr(new LayerTreeHostImpl(settings, client, proxy, renderingStatsRecorder));
 }
 
-LayerTreeHostImpl::LayerTreeHostImpl(const LayerTreeSettings& settings, LayerTreeHostImplClient* client, Proxy* proxy)
+LayerTreeHostImpl::LayerTreeHostImpl(const LayerTreeSettings& settings, LayerTreeHostImplClient* client, Proxy* proxy, RenderingStatsRecorder* renderingStatsRecorder)
     : m_client(client)
     , m_proxy(proxy)
     , m_didLockScrollingLayer(false)
     , m_shouldBubbleScrolls(false)
     , m_wheelScrolling(false)
     , m_settings(settings)
     , m_deviceScaleFactor(1)
     , m_visible(true)
     , m_managedMemoryPolicy(PrioritizedResourceManager::defaultMemoryAllocationLimit(),
                             ManagedMemoryPolicy::CUTOFF_ALLOW_EVERYTHING,
                             0,
                             ManagedMemoryPolicy::CUTOFF_ALLOW_NOTHING)
     , m_pinchGestureActive(false)
     , m_fpsCounter(FrameRateCounter::create(m_proxy->HasImplThread()))
     , m_paintTimeCounter(PaintTimeCounter::create())
     , m_memoryHistory(MemoryHistory::create())
     , m_debugRectHistory(DebugRectHistory::create())
-    , m_numImplThreadScrolls(0)
-    , m_numMainThreadScrolls(0)
-    , m_cumulativeNumLayersDrawn(0)
-    , m_cumulativeNumMissingTiles(0)
     , m_lastSentMemoryVisibleBytes(0)
     , m_lastSentMemoryVisibleAndNearbyBytes(0)
     , m_lastSentMemoryUseBytes(0)
     , m_animationRegistrar(AnimationRegistrar::create())
+    , m_renderingStatsRecorder(renderingStatsRecorder)
 {
     DCHECK(m_proxy->IsImplThread());
     didVisibilityChange(this, m_visible);
 
     setDebugState(settings.initialDebugState);
 
     if (settings.calculateTopControlsPosition) {
         m_topControlsManager = TopControlsManager::Create(this,
                                                           settings.topControlsHeight,
                                                           settings.topControlsShowThreshold,
@@ skipping 285 matching lines @@
         occlusionTracker.set_non_occluding_screen_space_rects_container(&frame.nonOccludingScreenSpaceRects);
 
     // Add quads to the Render passes in FrontToBack order to allow for testing occlusion and performing culling during the tree walk.
     typedef LayerIterator<LayerImpl, std::vector<LayerImpl*>, RenderSurfaceImpl, LayerIteratorActions::FrontToBack> LayerIteratorType;
 
     // Typically when we are missing a texture and use a checkerboard quad, we still draw the frame. However when the layer being
     // checkerboarded is moving due to an impl-animation, we drop the frame to avoid flashing due to the texture suddenly appearing
     // in the future.
     bool drawFrame = true;
 
+    int64 layersDrawn = 0;
+
     LayerIteratorType end = LayerIteratorType::end(frame.renderSurfaceLayerList);
     for (LayerIteratorType it = LayerIteratorType::begin(frame.renderSurfaceLayerList); it != end; ++it) {
         RenderPass::Id targetRenderPassId = it.targetRenderSurfaceLayer()->render_surface()->RenderPassId();
         RenderPass* targetRenderPass = frame.renderPassesById[targetRenderPassId];
 
         occlusionTracker.EnterLayer(it);
 
         AppendQuadsData appendQuadsData(targetRenderPass->id);
 
         if (it.representsContributingRenderSurface()) {
@@ skipping 18 matching lines @@
                         AppendQuadsData appendQuadsData(renderPass->id);
                         appendQuadsForLayer(renderPass, *it, occlusionTracker, appendQuadsData);
 
                         contributingRenderPassId = it->NextContributingRenderPassId(contributingRenderPassId);
                     }
                 }
 
                 appendQuadsForLayer(targetRenderPass, *it, occlusionTracker, appendQuadsData);
             }
 
-            ++m_cumulativeNumLayersDrawn;
+            layersDrawn++;

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

++layersDrawn is best practice

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

Done.

         }
 
         if (appendQuadsData.hadOcclusionFromOutsideTargetSurface)
           targetRenderPass->has_occlusion_from_outside_target_surface = true;
 
         if (appendQuadsData.numMissingTiles) {
-            m_cumulativeNumMissingTiles += appendQuadsData.numMissingTiles;
+            m_renderingStatsRecorder->AddMissingTiles(appendQuadsData.numMissingTiles);
             bool layerHasAnimatingTransform = it->screen_space_transform_is_animating() || it->draw_transform_is_animating();
             if (layerHasAnimatingTransform)
                 drawFrame = false;
         }
 
         if (appendQuadsData.hadIncompleteTile) 
             frame.containsIncompleteTile = true;
 
         occlusionTracker.LeaveLayer(it);
     }
 
+    m_renderingStatsRecorder->AddLayersDrawn(layersDrawn);
+
 #ifndef NDEBUG
     for (size_t i = 0; i < frame.renderPasses.size(); ++i) {
         for (size_t j = 0; j < frame.renderPasses[i]->quad_list.size(); ++j)
             DCHECK(frame.renderPasses[i]->quad_list[j]->shared_quad_state);
         DCHECK(frame.renderPassesById.find(frame.renderPasses[i]->id)
                != frame.renderPassesById.end());
     }
 #endif
     DCHECK(frame.renderPasses.back()->output_rect.origin().IsOrigin());
 
@@ skipping 254 matching lines @@
 void LayerTreeHostImpl::drawLayers(FrameData& frame)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::drawLayers");
     DCHECK(canDraw());
     DCHECK(!frame.renderPasses.empty());
 
     // FIXME: use the frame begin time from the overall compositor scheduler.
     // This value is currently inaccessible because it is up in Chromium's
     // RenderWidget.
     m_fpsCounter->saveTimeStamp(base::TimeTicks::Now());
+    m_renderingStatsRecorder->SetScreenAndDroppedFrameCount(m_fpsCounter->currentFrameNumber(), m_fpsCounter->droppedFrameCount());

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

"SetScreen" -> "SetFrameNumber" ? What's "Screen" in this context?

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

I split this weird double call into separate calls.

There's an open bug to rename the members numAnimationFrame and
numFramesSentToScreen of RenderingStats to animationFrameCount and
screenFrameCount (crbug.com/138641). So I used the better naming in the new
instrumentation class.

 
     if (m_tileManager) {
         m_memoryHistory->SaveEntry(
             m_tileManager->memory_stats_from_last_assign());
     }
 
     if (m_debugState.showHudRects())
         m_debugRectHistory->saveDebugRectsForCurrentFrame(rootLayer(), *frame.renderSurfaceLayerList, frame.occludingScreenSpaceRects, frame.nonOccludingScreenSpaceRects, m_debugState);
 
     if (m_debugState.traceAllRenderedFrames) {
@@ skipping 200 matching lines @@
 
     // Reduce wasted memory now that unlinked resources are guaranteed not
     // to be used.
     m_client->reduceWastedContentsTextureMemoryOnImplThread();
 
     m_client->onCanDrawStateChanged(canDraw());
     m_client->onHasPendingTreeStateChanged(pendingTree());
     m_client->setNeedsRedrawOnImplThread();
     m_client->renewTreePriority();
 
-    if (m_tileManager && m_debugState.continuousPainting) {
-        RenderingStats stats;
-        m_tileManager->GetRenderingStats(&stats);
-        m_paintTimeCounter->SaveRasterizeTime(stats.totalRasterizeTimeForNowBinsOnPendingTree, m_activeTree->source_frame_number());
-    }
+    if (m_tileManager && m_debugState.continuousPainting)
+        m_paintTimeCounter->SaveRasterizeTime(m_renderingStatsRecorder->GetRenderingStats().totalRasterizeTimeForNowBinsOnPendingTree, m_activeTree->source_frame_number());
 }
 
 void LayerTreeHostImpl::setVisible(bool visible)
 {
     DCHECK(m_proxy->IsImplThread());
 
     if (m_visible == visible)
         return;
     m_visible = visible;
     didVisibilityChange(this, m_visible);
@@ skipping 27 matching lines @@
     m_resourceProvider.reset();
     m_outputSurface.reset();
 
     if (!outputSurface->BindToClient(this))
         return false;
 
     scoped_ptr<ResourceProvider> resourceProvider = ResourceProvider::Create(outputSurface.get());
     if (!resourceProvider)
         return false;
 
-    if (m_settings.implSidePainting) {
+    if (m_settings.implSidePainting)

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

keep the {}

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

Done.

         m_tileManager.reset(new TileManager(this,
                                             resourceProvider.get(),
                                             m_settings.numRasterThreads,
+                                            m_renderingStatsRecorder,
                                             m_settings.useCheapnessEstimator,
                                             m_settings.useColorEstimator,
                                             m_settings.predictionBenchmarking));
-        m_tileManager->SetRecordRenderingStats(m_debugState.recordRenderingStats());
-    }
 
     if (outputSurface->capabilities().has_parent_compositor)
         m_renderer = DelegatingRenderer::Create(this, outputSurface.get(), resourceProvider.get());
     else if (outputSurface->context3d())
         m_renderer = GLRenderer::create(this, outputSurface.get(), resourceProvider.get());
     else if (outputSurface->software_device())
         m_renderer = SoftwareRenderer::Create(this, outputSurface.get(), resourceProvider.get());
     if (!m_renderer)
         return false;
 
@@ skipping 96 matching lines @@
 
     // First find out which layer was hit from the saved list of visible layers
     // in the most recent frame.
     LayerImpl* layerImpl = LayerTreeHostCommon::findLayerThatIsHitByPoint(deviceViewportPoint, activeTree()->RenderSurfaceLayerList());
 
     // Walk up the hierarchy and look for a scrollable layer.
     LayerImpl* potentiallyScrollingLayerImpl = 0;
     for (; layerImpl; layerImpl = layerImpl->parent()) {
         // The content layer can also block attempts to scroll outside the main thread.
         if (layerImpl->TryScroll(deviceViewportPoint, type) == ScrollOnMainThread) {
-            m_numMainThreadScrolls++;
+            m_renderingStatsRecorder->IncrementMainThreadScrolls();
             UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
             return ScrollOnMainThread;
         }
 
         LayerImpl* scrollLayerImpl = findScrollLayerForContentLayer(layerImpl);
         if (!scrollLayerImpl)
             continue;
 
         ScrollStatus status = scrollLayerImpl->TryScroll(deviceViewportPoint, type);
 
         // If any layer wants to divert the scroll event to the main thread, abort.
         if (status == ScrollOnMainThread) {
-            m_numMainThreadScrolls++;
+            m_renderingStatsRecorder->IncrementMainThreadScrolls();
             UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
             return ScrollOnMainThread;
         }
 
         if (status == ScrollStarted && !potentiallyScrollingLayerImpl)
             potentiallyScrollingLayerImpl = scrollLayerImpl;
     }
 
     // When hiding top controls is enabled and the controls are hidden or
     // overlaying the content, force scrolls to be enabled on the root layer to
     // allow bringing the top controls back into view.
     if (!potentiallyScrollingLayerImpl && m_topControlsManager &&
             m_topControlsManager->content_top_offset() != m_settings.topControlsHeight) {
         potentiallyScrollingLayerImpl = rootScrollLayer();
     }
 
     if (potentiallyScrollingLayerImpl) {
         m_activeTree->set_currently_scrolling_layer(potentiallyScrollingLayerImpl);
         m_shouldBubbleScrolls = (type != NonBubblingGesture);
         m_wheelScrolling = (type == Wheel);
-        m_numImplThreadScrolls++;
+        m_renderingStatsRecorder->IncrementImplThreadScrolls();
         m_client->renewTreePriority();
         UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
         return ScrollStarted;
     }
     return ScrollIgnored;
 }
 
 gfx::Vector2dF LayerTreeHostImpl::scrollLayerWithViewportSpaceDelta(LayerImpl* layerImpl, float scaleFromViewportToScreenSpace, gfx::PointF viewportPoint, gfx::Vector2dF viewportDelta)
 {
     // Layers with non-invertible screen space transforms should not have passed the scroll hit
@@ skipping 325 matching lines @@
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         dumpRenderSurfaces(str, indent, layer->children()[i]);
 }
 
 int LayerTreeHostImpl::sourceAnimationFrameNumber() const
 {
     return fpsCounter()->currentFrameNumber();
 }
 
-void LayerTreeHostImpl::renderingStats(RenderingStats* stats) const
-{
-    stats->numFramesSentToScreen = fpsCounter()->currentFrameNumber();
-    stats->droppedFrameCount = fpsCounter()->droppedFrameCount();
-    stats->numImplThreadScrolls = m_numImplThreadScrolls;
-    stats->numMainThreadScrolls = m_numMainThreadScrolls;
-    stats->numLayersDrawn = m_cumulativeNumLayersDrawn;
-    stats->numMissingTiles = m_cumulativeNumMissingTiles;
-
-    if (m_tileManager)
-        m_tileManager->GetRenderingStats(stats);
-}
-
 void LayerTreeHostImpl::sendManagedMemoryStats(
     size_t memoryVisibleBytes,
     size_t memoryVisibleAndNearbyBytes,
     size_t memoryUseBytes)
 {
     if (!renderer())
       return;
 
     // Round the numbers being sent up to the next 8MB, to throttle the rate
     // at which we spam the GPU process.
@@ skipping 111 matching lines @@
     LayerImpl* layer = getNonCompositedContentLayerRecursive(tree->RootLayer());
     return layer ? layer->GetPicture() : skia::RefPtr<SkPicture>();
 }
 
 void LayerTreeHostImpl::setDebugState(const LayerTreeDebugState& debugState)
 {
     if (m_debugState.continuousPainting != debugState.continuousPainting)
         m_paintTimeCounter->ClearHistory();
 
     m_debugState = debugState;
-
-    if (m_tileManager)
-        m_tileManager->SetRecordRenderingStats(m_debugState.recordRenderingStats());
 }
 
 void LayerTreeHostImpl::savePaintTime(const base::TimeDelta& totalPaintTime, int commitNumber)
 {
     DCHECK(m_debugState.continuousPainting);
     m_paintTimeCounter->SavePaintTime(totalPaintTime, commitNumber);
 }
 
 }  // namespace cc