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"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "cc/animation_registrar.h"
 #include "cc/heads_up_display_layer.h"
 #include "cc/heads_up_display_layer_impl.h"
 #include "cc/layer.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/layer_iterator.h"
 #include "cc/layer_tree_host_client.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/layer_tree_host_impl.h"
 #include "cc/layer_tree_impl.h"
 #include "cc/math_util.h"
 #include "cc/occlusion_tracker.h"
 #include "cc/overdraw_metrics.h"
 #include "cc/prioritized_resource_manager.h"
+#include "cc/rendering_stats_instrumentation.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/switches.h"
 #include "cc/thread.h"
 #include "cc/thread_proxy.h"
 #include "cc/top_controls_manager.h"
 #include "cc/tree_synchronizer.h"
 
 namespace {
 static int s_num_layer_tree_instances;
 }
@@ skipping 30 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.initialDebugState),
       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_.acceleratedAnimationEnabled)
     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 86 matching lines @@
     if (sync_tree->ContentsTexturesPurged())
       sync_tree->ResetContentsTexturesPurged();
   }
 
   if (!settings_.implSidePainting) {
     // If we're not in impl-side painting, the tree is immediately
     // considered active.
     sync_tree->DidBecomeActive();
   }
 
-  if (debug_state_.continuousPainting)
-    host_impl->SavePaintTime(rendering_stats_.totalPaintTime, commit_number());
+  if (debug_state_.continuousPainting) {
+    host_impl->SavePaintTime(
+        rendering_stats_instrumentation_->GetRenderingStats().totalPaintTime,
+        commit_number());
+  }
 
   commit_number_++;
 }
 
 void LayerTreeHost::WillCommit() {
   client_->willCommit();
 }
 
 void LayerTreeHost::UpdateHudLayer() {
   if (debug_state_.showHudInfo()) {
@@ skipping 17 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_.calculateTopControlsPosition &&
       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 48 matching lines @@
 
 void LayerTreeHost::SetDebugState(const LayerTreeDebugState& debug_state) {
   LayerTreeDebugState new_debug_state =
       LayerTreeDebugState::unite(settings_.initialDebugState, debug_state);
 
   if (LayerTreeDebugState::equal(debug_state_, new_debug_state))
     return;
 
   debug_state_ = new_debug_state;
   SetNeedsCommit();
+
+  rendering_stats_instrumentation_->set_record_rendering_stats(

[danakj, 2013/03/15 17:28:48]

The general pattern is to change states, then call setNeedsCommit() last.

[egraether, 2013/03/15 21:14:26]

Done.

+      debug_state_.recordRenderingStats());
 }
 
 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;
   device_viewport_size_ = device_viewport_size;
@@ skipping 212 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_.minimumOcclusionTrackingSize);
 
   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.representsTargetRenderSurface()) {
       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.representsItself()) {
       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