cc: Avoid expensive RenderingStats collection.

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/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 391 matching lines @@
 {
     m_proxy->setDeferCommits(deferCommits);
 }
 
 void LayerTreeHost::didDeferCommit()
 {
 }
 
 void LayerTreeHost::renderingStats(RenderingStats* stats) const
 {
+    CHECK(m_settings.recordRenderingStats);
     *stats = m_renderingStats;
     m_proxy->renderingStats(stats);
 }
 
 const RendererCapabilities& LayerTreeHost::rendererCapabilities() const
 {
     return m_proxy->rendererCapabilities();
 }
 
 void LayerTreeHost::setNeedsAnimate()
@@ skipping 270 matching lines @@
     }
     return readbackBytes + maxBackgroundTextureBytes + contentsTextureBytes;
 }
 
 bool LayerTreeHost::paintMasksForRenderSurface(Layer* renderSurfaceLayer, ResourceUpdateQueue& queue)
 {
     // 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_settings.recordRenderingStats ? &m_renderingStats : NULL;
+
     bool needMoreUpdates = false;
     Layer* maskLayer = renderSurfaceLayer->maskLayer();
     if (maskLayer) {
-        maskLayer->update(queue, 0, m_renderingStats);
+        maskLayer->update(queue, 0, stats);
         needMoreUpdates |= maskLayer->needMoreUpdates();
     }
 
     Layer* replicaMaskLayer = renderSurfaceLayer->replicaLayer() ? renderSurfaceLayer->replicaLayer()->maskLayer() : 0;
     if (replicaMaskLayer) {
-        replicaMaskLayer->update(queue, 0, m_renderingStats);
+        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->renderSurface()->contentRect(), recordMetricsForFrame);
     occlusionTracker.setMinimumTrackingSize(m_settings.minimumOcclusionTrackingSize);
 
     prioritizeTextures(renderSurfaceLayerList, occlusionTracker.overdrawMetrics());
 
+    RenderingStats* stats = m_settings.recordRenderingStats ? &m_renderingStats : NULL;
+
     LayerIteratorType end = LayerIteratorType::end(&renderSurfaceLayerList);
     for (LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList); it != end; ++it) {
         occlusionTracker.enterLayer(it);
 
         if (it.representsTargetRenderSurface()) {
             DCHECK(it->renderSurface()->drawOpacity() || it->renderSurface()->drawOpacityIsAnimating());
             needMoreUpdates |= paintMasksForRenderSurface(*it, queue);
         } else if (it.representsItself()) {
             DCHECK(!it->bounds().IsEmpty());
-            it->update(queue, &occlusionTracker, m_renderingStats);
+            it->update(queue, &occlusionTracker, stats);
             needMoreUpdates |= it->needMoreUpdates();
         }
 
         occlusionTracker.leaveLayer(it);
     }
 
     occlusionTracker.overdrawMetrics().recordMetrics(this);
 
     return needMoreUpdates;
 }
@@ skipping 117 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