cc: Switch RenderingStats collection in Layer::Update() to RenderingStatsInstrumentation

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"
@@ skipping 792 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,
-                                               RenderingStats* stats) {
+                                               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.
 
   bool need_more_updates = false;
   Layer* mask_layer = render_surface_layer->mask_layer();
   if (mask_layer) {
-    mask_layer->Update(queue, NULL, stats);
+    mask_layer->Update(queue, NULL);
     need_more_updates |= mask_layer->NeedMoreUpdates();
   }
 
   Layer* replica_mask_layer =
       render_surface_layer->replica_layer() ?
       render_surface_layer->replica_layer()->mask_layer() : NULL;
   if (replica_mask_layer) {
-    replica_mask_layer->Update(queue, NULL, stats);
+    replica_mask_layer->Update(queue, NULL);
     need_more_updates |= replica_mask_layer->NeedMoreUpdates();
   }
   return need_more_updates;
 }
 
 bool LayerTreeHost::PaintLayerContents(
     const LayerList& render_surface_layer_list, 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 need_more_updates = false;
   bool record_metrics_for_frame =
       settings_.show_overdraw_in_tracing &&
       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());
 
-  // 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, stats_ptr);
+      need_more_updates |= PaintMasksForRenderSurface(*it, queue);
     } else if (it.represents_itself()) {
       DCHECK(!it->bounds().IsEmpty());
-      it->Update(queue, &occlusion_tracker, stats_ptr);
+      it->Update(queue, &occlusion_tracker);
       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