cc:: Add RenderingStatsInstrumentation to manage collection of RenderingStats

cc/trees/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/trees/layer_tree_host.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/base/thread.h"
 #include "cc/debug/overdraw_metrics.h"
+#include "cc/debug/rendering_stats_instrumentation.h"
 #include "cc/input/pinch_zoom_scrollbar.h"
 #include "cc/input/pinch_zoom_scrollbar_geometry.h"
 #include "cc/input/pinch_zoom_scrollbar_painter.h"
 #include "cc/input/top_controls_manager.h"
 #include "cc/layers/heads_up_display_layer.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_iterator.h"
 #include "cc/layers/scrollbar_layer.h"
 #include "cc/resources/prioritized_resource_manager.h"
@@ skipping 42 matching lines @@
   return layer_tree_host.Pass();
 }
 
 LayerTreeHost::LayerTreeHost(LayerTreeHostClient* client,
                              const LayerTreeSettings& settings)
     : animating_(false),
       needs_full_tree_sync_(true),
       needs_filter_context_(false),
       client_(client),
       commit_number_(0),
-      rendering_stats_(),
+      rendering_stats_instrumentation_(RenderingStatsInstrumentation::Create()),
       renderer_initialized_(false),
       output_surface_lost_(false),
       num_failed_recreate_attempts_(0),
       settings_(settings),
       debug_state_(settings.initial_debug_state),
       device_scale_factor_(1.f),
       visible_(true),
       page_scale_factor_(1.f),
       min_page_scale_factor_(1.f),
       max_page_scale_factor_(1.f),
       trigger_idle_updates_(true),
       background_color_(SK_ColorWHITE),
       has_transparent_background_(false),
       partial_texture_update_requests_(0) {
   if (settings_.accelerated_animation_enabled)
     animation_registrar_ = AnimationRegistrar::Create();
   s_num_layer_tree_instances++;
+
+  rendering_stats_instrumentation_->set_record_rendering_stats(
+      debug_state_.RecordRenderingStats());
 }
 
 bool LayerTreeHost::Initialize(scoped_ptr<Thread> impl_thread) {
   if (impl_thread)
     return InitializeProxy(ThreadProxy::Create(this, impl_thread.Pass()));
   else
     return InitializeProxy(SingleThreadProxy::Create(this));
 }
 
 bool LayerTreeHost::InitializeForTesting(scoped_ptr<Proxy> proxy_for_testing) {
@@ skipping 115 matching lines @@
 void LayerTreeHost::DidBeginFrame() {
   client_->DidBeginFrame();
 }
 
 void LayerTreeHost::UpdateAnimations(base::TimeTicks frame_begin_time) {
   animating_ = true;
   client_->Animate((frame_begin_time - base::TimeTicks()).InSecondsF());
   AnimateLayers(frame_begin_time);
   animating_ = false;
 
-  rendering_stats_.numAnimationFrames++;
+  rendering_stats_instrumentation_->IncrementAnimationFrameCount();
 }
 
 void LayerTreeHost::DidStopFlinging() {
   proxy_->MainThreadHasStoppedFlinging();
 }
 
 void LayerTreeHost::Layout() {
   client_->Layout();
 }
 
@@ skipping 94 matching lines @@
   sync_tree->SetPinchZoomVerticalLayerId(
       pinch_zoom_scrollbar_vertical_ ?
           pinch_zoom_scrollbar_vertical_->id() : Layer::INVALID_ID);
 
   if (!settings_.impl_side_painting) {
     // If we're not in impl-side painting, the tree is immediately
     // considered active.
     sync_tree->DidBecomeActive();
   }
 
-  if (debug_state_.continuous_painting)
-    host_impl->SavePaintTime(rendering_stats_.totalPaintTime, commit_number());
+  if (debug_state_.continuous_painting) {
+    host_impl->SavePaintTime(
+      rendering_stats_instrumentation_->GetRenderingStats().totalPaintTime,
+      commit_number()
+    );
+  }
 
   commit_number_++;
 }
 
 void LayerTreeHost::SetPinchZoomScrollbarsBoundsAndPosition() {
   if (!pinch_zoom_scrollbar_horizontal_ || !pinch_zoom_scrollbar_vertical_)
     return;
 
   gfx::Size size = layout_viewport_size();
   int track_width = PinchZoomScrollbarGeometry::kTrackWidth;
@@ skipping 76 matching lines @@
 }
 
 scoped_ptr<InputHandler> LayerTreeHost::CreateInputHandler() {
   return client_->CreateInputHandler();
 }
 
 scoped_ptr<LayerTreeHostImpl> LayerTreeHost::CreateLayerTreeHostImpl(
     LayerTreeHostImplClient* client) {
   DCHECK(proxy_->IsImplThread());
   scoped_ptr<LayerTreeHostImpl> host_impl =
-      LayerTreeHostImpl::Create(settings_, client, proxy_.get());
+      LayerTreeHostImpl::Create(settings_,
+                                client,
+                                proxy_.get(),
+                                rendering_stats_instrumentation_.get());
   if (settings_.calculate_top_controls_position &&
       host_impl->top_controls_manager()) {
     top_controls_manager_weak_ptr_ =
         host_impl->top_controls_manager()->AsWeakPtr();
   }
   return host_impl.Pass();
 }
 
 void LayerTreeHost::DidLoseOutputSurface() {
   TRACE_EVENT0("cc", "LayerTreeHost::DidLoseOutputSurface");
@@ skipping 18 matching lines @@
 }
 
 void LayerTreeHost::SetDeferCommits(bool defer_commits) {
   proxy_->SetDeferCommits(defer_commits);
 }
 
 void LayerTreeHost::DidDeferCommit() {}
 
 void LayerTreeHost::CollectRenderingStats(RenderingStats* stats) const {
   CHECK(debug_state_.RecordRenderingStats());
-  *stats = rendering_stats_;
-  proxy_->CollectRenderingStats(stats);
+  *stats = rendering_stats_instrumentation_->GetRenderingStats();
 }
 
 const RendererCapabilities& LayerTreeHost::GetRendererCapabilities() const {
   return proxy_->GetRendererCapabilities();
 }
 
 void LayerTreeHost::SetNeedsAnimate() {
   DCHECK(proxy_->HasImplThread());
   proxy_->SetNeedsAnimate();
 }
@@ skipping 53 matching lines @@
 }
 
 void LayerTreeHost::SetDebugState(const LayerTreeDebugState& debug_state) {
   LayerTreeDebugState new_debug_state =
       LayerTreeDebugState::Unite(settings_.initial_debug_state, debug_state);
 
   if (LayerTreeDebugState::Equal(debug_state_, new_debug_state))
     return;
 
   debug_state_ = new_debug_state;
+
+  rendering_stats_instrumentation_->set_record_rendering_stats(
+      debug_state_.RecordRenderingStats());
+
   SetNeedsCommit();
 }
 
 void LayerTreeHost::SetViewportSize(gfx::Size layout_viewport_size,
                                     gfx::Size device_viewport_size) {
   if (layout_viewport_size == layout_viewport_size_ &&
       device_viewport_size == device_viewport_size_)
     return;
 
   layout_viewport_size_ = layout_viewport_size;
@@ skipping 219 matching lines @@
       max_background_texture_bytes = bytes;
     if (!readback_bytes) {
       readback_bytes = Resource::MemorySizeBytes(device_viewport_size_,
                                                  GL_RGBA);
     }
   }
   return readback_bytes + max_background_texture_bytes + contents_texture_bytes;
 }
 
 bool LayerTreeHost::PaintMasksForRenderSurface(Layer* render_surface_layer,
-                                               ResourceUpdateQueue* queue) {
+                                               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 =
-      debug_state_.RecordRenderingStats() ? &rendering_stats_ : NULL;
-
   bool need_more_updates = false;
   Layer* mask_layer = render_surface_layer->mask_layer();
   if (mask_layer) {
     mask_layer->Update(queue, NULL, stats);
     need_more_updates |= mask_layer->NeedMoreUpdates();
   }
 
   Layer* replica_mask_layer =
       render_surface_layer->replica_layer() ?
       render_surface_layer->replica_layer()->mask_layer() : NULL;
@@ skipping 19 matching lines @@
       base::debug::TraceLog::GetInstance() &&
       base::debug::TraceLog::GetInstance()->IsEnabled();
   OcclusionTracker occlusion_tracker(
       root_layer_->render_surface()->content_rect(), record_metrics_for_frame);
   occlusion_tracker.set_minimum_tracking_size(
       settings_.minimum_occlusion_tracking_size);
 
   PrioritizeTextures(render_surface_layer_list,
                      occlusion_tracker.overdraw_metrics());
 
-  RenderingStats* stats = debug_state_.RecordRenderingStats() ?
-                          &rendering_stats_ : NULL;
+  // TODO(egraether): Use RenderingStatsInstrumentation in Layer::update()
+  RenderingStats stats;
+  RenderingStats* stats_ptr =
+      debug_state_.RecordRenderingStats() ? &stats : NULL;
 
   LayerIteratorType end = LayerIteratorType::End(&render_surface_layer_list);
   for (LayerIteratorType it =
            LayerIteratorType::Begin(&render_surface_layer_list);
        it != end;
        ++it) {
     occlusion_tracker.EnterLayer(it);
 
     if (it.represents_target_render_surface()) {
       DCHECK(it->render_surface()->draw_opacity() ||
              it->render_surface()->draw_opacity_is_animating());
-      need_more_updates |= PaintMasksForRenderSurface(*it, queue);
+      need_more_updates |= PaintMasksForRenderSurface(*it, queue, stats_ptr);
     } else if (it.represents_itself()) {
       DCHECK(!it->bounds().IsEmpty());
-      it->Update(queue, &occlusion_tracker, stats);
+      it->Update(queue, &occlusion_tracker, stats_ptr);
       need_more_updates |= it->NeedMoreUpdates();
     }
 
     occlusion_tracker.LeaveLayer(it);
   }
 
+  rendering_stats_instrumentation_->AddStats(stats);
+
   occlusion_tracker.overdraw_metrics()->RecordMetrics(this);
 
   return need_more_updates;
 }
 
 void LayerTreeHost::ApplyScrollAndScale(const ScrollAndScaleSet& info) {
   if (!root_layer_)
     return;
 
   Layer* root_scroll_layer = FindFirstScrollableLayer(root_layer_.get());
@@ skipping 141 matching lines @@
     SetAnimationEventsRecursive(events,
                                 layer->children()[child_index].get(),
                                 wall_clock_time);
 }
 
 skia::RefPtr<SkPicture> LayerTreeHost::CapturePicture() {
   return proxy_->CapturePicture();
 }
 
 }  // namespace cc