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 123 matching lines @@
 };
 
 LayerTreeHostImpl::FrameData::FrameData()
     : contains_incomplete_tile(false) {}
 
 LayerTreeHostImpl::FrameData::~FrameData() {}
 
 scoped_ptr<LayerTreeHostImpl> LayerTreeHostImpl::Create(
     const LayerTreeSettings& settings,
     LayerTreeHostImplClient* client,
-    Proxy* proxy) {
-  return make_scoped_ptr(new LayerTreeHostImpl(settings, client, proxy));
+    Proxy* proxy,
+    RenderingStatsInstrumentation* rendering_stats_instrumentation) {
+  return make_scoped_ptr(
+      new LayerTreeHostImpl(settings,
+                            client,
+                            proxy,
+                            rendering_stats_instrumentation));
 }
 
-LayerTreeHostImpl::LayerTreeHostImpl(const LayerTreeSettings& settings,
-                                     LayerTreeHostImplClient* client,
-                                     Proxy* proxy)
+LayerTreeHostImpl::LayerTreeHostImpl(
+    const LayerTreeSettings& settings,
+    LayerTreeHostImplClient* client,
+    Proxy* proxy,
+    RenderingStatsInstrumentation* rendering_stats_instrumentation)
     : client_(client),
       proxy_(proxy),
       did_lock_scrolling_layer_(false),
       should_bubble_scrolls_(false),
       wheel_scrolling_(false),
       settings_(settings),
       device_scale_factor_(1.f),
       visible_(true),
       managed_memory_policy_(
           PrioritizedResourceManager::defaultMemoryAllocationLimit(),
           ManagedMemoryPolicy::CUTOFF_ALLOW_EVERYTHING,
           0,
           ManagedMemoryPolicy::CUTOFF_ALLOW_NOTHING),
       pinch_gesture_active_(false),
       fps_counter_(FrameRateCounter::create(proxy_->HasImplThread())),
       paint_time_counter_(PaintTimeCounter::create()),
       memory_history_(MemoryHistory::Create()),
       debug_rect_history_(DebugRectHistory::Create()),
-      num_impl_thread_scrolls_(0),
-      num_main_thread_scrolls_(0),
-      cumulative_num_layers_drawn_(0),
-      cumulative_num_missing_tiles_(0),
       last_sent_memory_visible_bytes_(0),
       last_sent_memory_visible_and_nearby_bytes_(0),
       last_sent_memory_use_bytes_(0),
-      animation_registrar_(AnimationRegistrar::create()) {
+      animation_registrar_(AnimationRegistrar::create()),
+      rendering_stats_instrumentation_(rendering_stats_instrumentation) {
   DCHECK(proxy_->IsImplThread());
   DidVisibilityChange(this, visible_);
 
   SetDebugState(settings.initialDebugState);
 
   if (settings.calculateTopControlsPosition) {
     top_controls_manager_ =
         TopControlsManager::Create(this,
                                    settings.topControlsHeight,
                                    settings.topControlsShowThreshold,
@@ skipping 342 matching lines @@
                         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 draw_frame = true;
 
+  int layers_drawn = 0;
+
   LayerIteratorType end =
       LayerIteratorType::end(frame->render_surface_layer_list);
   for (LayerIteratorType it =
            LayerIteratorType::begin(frame->render_surface_layer_list);
        it != end;
        ++it) {
     RenderPass::Id target_render_pass_id =
         it.targetRenderSurfaceLayer()->render_surface()->RenderPassId();
     RenderPass* target_render_pass =
         frame->render_passes_by_id[target_render_pass_id];
@@ skipping 48 matching lines @@
                 it->NextContributingRenderPassId(contributing_render_pass_id);
           }
         }
 
         AppendQuadsForLayer(target_render_pass,
                             *it,
                             occlusion_tracker,
                             &append_quads_data);
       }
 
-      ++cumulative_num_layers_drawn_;
+      ++layers_drawn;
     }
 
     if (append_quads_data.hadOcclusionFromOutsideTargetSurface)
       target_render_pass->has_occlusion_from_outside_target_surface = true;
 
     if (append_quads_data.numMissingTiles) {
-      cumulative_num_missing_tiles_ += append_quads_data.numMissingTiles;
+      rendering_stats_instrumentation_->AddMissingTiles(
+          append_quads_data.numMissingTiles);
       bool layer_has_animating_transform =
           it->screen_space_transform_is_animating() ||
           it->draw_transform_is_animating();
       if (layer_has_animating_transform)
         draw_frame = false;
     }
 
     if (append_quads_data.hadIncompleteTile)
       frame->contains_incomplete_tile = true;
 
     occlusion_tracker.LeaveLayer(it);
   }
 
+  rendering_stats_instrumentation_->AddLayersDrawn(layers_drawn);
+
 #ifndef NDEBUG
   for (size_t i = 0; i < frame->render_passes.size(); ++i) {
     for (size_t j = 0; j < frame->render_passes[i]->quad_list.size(); ++j)
       DCHECK(frame->render_passes[i]->quad_list[j]->shared_quad_state);
     DCHECK(frame->render_passes_by_id.find(frame->render_passes[i]->id)
            != frame->render_passes_by_id.end());
   }
 #endif
   DCHECK(frame->render_passes.back()->output_rect.origin().IsOrigin());
 
@@ skipping 295 matching lines @@
 void LayerTreeHostImpl::DrawLayers(FrameData* frame) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::DrawLayers");
   DCHECK(CanDraw());
   DCHECK(!frame->render_passes.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.
   fps_counter_->saveTimeStamp(base::TimeTicks::Now());
 
+  rendering_stats_instrumentation_->SetScreenFrameCount(
+      fps_counter_->currentFrameNumber());
+  rendering_stats_instrumentation_->SetDroppedFrameCount(
+      fps_counter_->droppedFrameCount());
+
   if (tile_manager_) {
     memory_history_->SaveEntry(
         tile_manager_->memory_stats_from_last_assign());
   }
 
   if (debug_state_.showHudRects()) {
     debug_rect_history_->SaveDebugRectsForCurrentFrame(
         active_tree_->root_layer(),
         *frame->render_surface_layer_list,
         frame->occluding_screen_space_rects,
@@ skipping 202 matching lines @@
   // Reduce wasted memory now that unlinked resources are guaranteed not
   // to be used.
   client_->ReduceWastedContentsTextureMemoryOnImplThread();
 
   client_->OnCanDrawStateChanged(CanDraw());
   client_->OnHasPendingTreeStateChanged(pending_tree_);
   client_->SetNeedsRedrawOnImplThread();
   client_->RenewTreePriority();
 
   if (tile_manager_ && debug_state_.continuousPainting) {
-    RenderingStats stats;
-    tile_manager_->GetRenderingStats(&stats);
+    RenderingStats stats =
+        rendering_stats_instrumentation_->GetRenderingStats();
     paint_time_counter_->SaveRasterizeTime(
         stats.totalRasterizeTimeForNowBinsOnPendingTree,
         active_tree_->source_frame_number());
   }
 }
 
 void LayerTreeHostImpl::SetVisible(bool visible) {
   DCHECK(proxy_->IsImplThread());
 
   if (visible_ == visible)
@@ skipping 39 matching lines @@
       ResourceProvider::Create(output_surface.get());
   if (!resource_provider)
     return false;
 
   if (settings_.implSidePainting) {
     tile_manager_.reset(new TileManager(this,
                                         resource_provider.get(),
                                         settings_.numRasterThreads,
                                         settings_.useCheapnessEstimator,
                                         settings_.useColorEstimator,
-                                        settings_.predictionBenchmarking));
-    tile_manager_->SetRecordRenderingStats(debug_state_.recordRenderingStats());
+                                        settings_.predictionBenchmarking,
+                                        rendering_stats_instrumentation_));
   }
 
   if (output_surface->capabilities().has_parent_compositor) {
     renderer_ = DelegatingRenderer::Create(this, output_surface.get(),
                                            resource_provider.get());
   } else if (output_surface->context3d()) {
     renderer_ = GLRenderer::Create(this,
                                    output_surface.get(),
                                    resource_provider.get());
   } else if (output_surface->software_device()) {
@@ skipping 104 matching lines @@
   LayerImpl* layer_impl = LayerTreeHostCommon::findLayerThatIsHitByPoint(
       device_viewport_point, active_tree_->RenderSurfaceLayerList());
 
   // Walk up the hierarchy and look for a scrollable layer.
   LayerImpl* potentially_scrolling_layer_impl = 0;
   for (; layer_impl; layer_impl = layer_impl->parent()) {
     // The content layer can also block attempts to scroll outside the main
     // thread.
     ScrollStatus status = layer_impl->TryScroll(device_viewport_point, type);
     if (status == ScrollOnMainThread) {
-      num_main_thread_scrolls_++;
+      rendering_stats_instrumentation_->IncrementMainThreadScrolls();
       UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
       return ScrollOnMainThread;
     }
 
     LayerImpl* scroll_layer_impl = FindScrollLayerForContentLayer(layer_impl);
     if (!scroll_layer_impl)
       continue;
 
     status = scroll_layer_impl->TryScroll(device_viewport_point, type);
 
     // If any layer wants to divert the scroll event to the main thread, abort.
     if (status == ScrollOnMainThread) {
-      num_main_thread_scrolls_++;
+      rendering_stats_instrumentation_->IncrementMainThreadScrolls();
       UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
       return ScrollOnMainThread;
     }
 
     if (status == ScrollStarted && !potentially_scrolling_layer_impl)
       potentially_scrolling_layer_impl = scroll_layer_impl;
   }
 
   // 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 (!potentially_scrolling_layer_impl && top_controls_manager_ &&
       top_controls_manager_->content_top_offset() !=
       settings_.topControlsHeight) {
     potentially_scrolling_layer_impl = RootScrollLayer();
   }
 
   if (potentially_scrolling_layer_impl) {
     active_tree_->set_currently_scrolling_layer(
         potentially_scrolling_layer_impl);
     should_bubble_scrolls_ = (type != NonBubblingGesture);
     wheel_scrolling_ = (type == Wheel);
-    num_impl_thread_scrolls_++;
+    rendering_stats_instrumentation_->IncrementImplThreadScrolls();
     client_->RenewTreePriority();
     UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
     return ScrollStarted;
   }
   return ScrollIgnored;
 }
 
 gfx::Vector2dF LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
     LayerImpl* layer_impl,
     float scale_from_viewport_to_screen_space,
@@ skipping 372 matching lines @@
     layer->render_surface()->DumpSurface(str, indent);
 
   for (size_t i = 0; i < layer->children().size(); ++i)
     DumpRenderSurfaces(str, indent, layer->children()[i]);
 }
 
 int LayerTreeHostImpl::SourceAnimationFrameNumber() const {
   return fps_counter_->currentFrameNumber();
 }
 
-void LayerTreeHostImpl::CollectRenderingStats(RenderingStats* stats) const {
-  stats->numFramesSentToScreen = fps_counter_->currentFrameNumber();
-  stats->droppedFrameCount = fps_counter_->droppedFrameCount();
-  stats->numImplThreadScrolls = num_impl_thread_scrolls_;
-  stats->numMainThreadScrolls = num_main_thread_scrolls_;
-  stats->numLayersDrawn = cumulative_num_layers_drawn_;
-  stats->numMissingTiles = cumulative_num_missing_tiles_;
-
-  if (tile_manager_)
-    tile_manager_->GetRenderingStats(stats);
-}
-
 void LayerTreeHostImpl::SendManagedMemoryStats(
     size_t memory_visible_bytes,
     size_t memory_visible_and_nearby_bytes,
     size_t memory_use_bytes) {
   if (!renderer_)
     return;
 
   // Round the numbers being sent up to the next 8MB, to throttle the rate
   // at which we spam the GPU process.
   static const size_t rounding_step = 8 * 1024 * 1024;
@@ skipping 107 matching lines @@
       pending_tree_ ? pending_tree_.get() : active_tree_.get();
   LayerImpl* layer = GetNonCompositedContentLayerRecursive(tree->root_layer());
   return layer ? layer->GetPicture() : skia::RefPtr<SkPicture>();
 }
 
 void LayerTreeHostImpl::SetDebugState(const LayerTreeDebugState& debug_state) {
   if (debug_state_.continuousPainting != debug_state.continuousPainting)
     paint_time_counter_->ClearHistory();
 
   debug_state_ = debug_state;
-
-  if (tile_manager_)
-    tile_manager_->SetRecordRenderingStats(debug_state_.recordRenderingStats());
 }
 
 void LayerTreeHostImpl::SavePaintTime(const base::TimeDelta& total_paint_time,
                                       int commit_number) {
   DCHECK(debug_state_.continuousPainting);
   paint_time_counter_->SavePaintTime(total_paint_time, commit_number);
 }
 
 }  // namespace cc