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

cc/layers/scrollbar_layer.cc

 // Copyright 2012 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/layers/scrollbar_layer.h"
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
 #include "cc/layers/scrollbar_layer_impl.h"
 #include "cc/resources/caching_bitmap_content_layer_updater.h"
@@ skipping 253 matching lines @@
 
   texture_format_ =
       layer_tree_host()->GetRendererCapabilities().best_texture_format;
 
   if (!back_track_updater_) {
     back_track_updater_ = CachingBitmapContentLayerUpdater::Create(
         ScrollbarBackgroundPainter::Create(
             scrollbar_.get(),
             painter_.get(),
             geometry_.get(),
-            WebKit::WebScrollbar::BackTrackPart).PassAs<LayerPainter>());
+            WebKit::WebScrollbar::BackTrackPart).PassAs<LayerPainter>(),
+        rendering_stats_instrumentation());
   }
   if (!back_track_) {
     back_track_ = back_track_updater_->CreateResource(
         layer_tree_host()->contents_texture_manager());
   }
 
   // Only create two-part track if we think the two parts could be different in
   // appearance.
   if (scrollbar_->isCustomScrollbar()) {
     if (!fore_track_updater_) {
       fore_track_updater_ = CachingBitmapContentLayerUpdater::Create(
           ScrollbarBackgroundPainter::Create(
               scrollbar_.get(),
               painter_.get(),
               geometry_.get(),
-              WebKit::WebScrollbar::ForwardTrackPart).PassAs<LayerPainter>());
+              WebKit::WebScrollbar::ForwardTrackPart).PassAs<LayerPainter>(),
+          rendering_stats_instrumentation());
     }
     if (!fore_track_) {
       fore_track_ = fore_track_updater_->CreateResource(
           layer_tree_host()->contents_texture_manager());
     }
   }
 
   if (!thumb_updater_) {
     thumb_updater_ = CachingBitmapContentLayerUpdater::Create(
         ScrollbarThumbPainter::Create(scrollbar_.get(),
                                       painter_.get(),
-                                      geometry_.get()).PassAs<LayerPainter>());
+                                      geometry_.get()).PassAs<LayerPainter>(),
+        rendering_stats_instrumentation());
   }
   if (!thumb_) {
     thumb_ = thumb_updater_->CreateResource(
         layer_tree_host()->contents_texture_manager());
   }
 }
 
 void ScrollbarLayer::UpdatePart(CachingBitmapContentLayerUpdater* painter,
                                 LayerUpdater::Resource* resource,
                                 gfx::Rect rect,
-                                ResourceUpdateQueue* queue,
-                                RenderingStats* stats) {
+                                ResourceUpdateQueue* queue) {
   if (layer_tree_host()->settings().solid_color_scrollbars)
     return;
 
   // Skip painting and uploading if there are no invalidations and
   // we already have valid texture data.
   if (resource->texture()->have_backing_texture() &&
       resource->texture()->size() == rect.size() &&
       !is_dirty())
     return;
 
   // We should always have enough memory for UI.
   DCHECK(resource->texture()->can_acquire_backing_texture());
   if (!resource->texture()->can_acquire_backing_texture())
     return;
 
   // Paint and upload the entire part.
   gfx::Rect painted_opaque_rect;
   painter->PrepareToUpdate(rect,
                            rect.size(),
                            contents_scale_x(),
                            contents_scale_y(),
-                           &painted_opaque_rect,
-                           stats);
+                           &painted_opaque_rect);
   if (!painter->pixels_did_change() &&
       resource->texture()->have_backing_texture()) {
     TRACE_EVENT_INSTANT0("cc",
                          "ScrollbarLayer::updatePart no texture upload needed");
     return;
   }
 
   bool partial_updates_allowed =
       layer_tree_host()->settings().max_partial_texture_updates > 0;
   if (!partial_updates_allowed)
     resource->texture()->ReturnBackingTexture();
 
   gfx::Vector2d dest_offset(0, 0);
-  resource->Update(queue, rect, dest_offset, partial_updates_allowed, stats);
+  resource->Update(queue, rect, dest_offset, partial_updates_allowed);
 }
 
 gfx::Rect ScrollbarLayer::ScrollbarLayerRectToContentRect(
     gfx::Rect layer_rect) const {
   // Don't intersect with the bounds as in LayerRectToContentRect() because
   // layer_rect here might be in coordinates of the containing layer.
   gfx::RectF content_rect = gfx::ScaleRect(layer_rect,
                                            contents_scale_y(),
                                            contents_scale_y());
   return gfx::ToEnclosingRect(content_rect);
@@ skipping 26 matching lines @@
     gfx::Rect thumb_layer_rect = geometry_->thumbRect(scrollbar_.get());
     gfx::Size thumb_size =
         ScrollbarLayerRectToContentRect(thumb_layer_rect).size();
     thumb_->texture()->SetDimensions(thumb_size, texture_format_);
     thumb_->texture()->set_request_priority(
         PriorityCalculator::UIPriority(draws_to_root));
   }
 }
 
 void ScrollbarLayer::Update(ResourceUpdateQueue* queue,
-                            const OcclusionTracker* occlusion,
-                            RenderingStats* stats) {
-  ContentsScalingLayer::Update(queue, occlusion, stats);
+                            const OcclusionTracker* occlusion) {
+  ContentsScalingLayer::Update(queue, occlusion);
 
   dirty_rect_.Union(update_rect_);
   if (content_bounds().IsEmpty())
     return;
   if (visible_content_rect().IsEmpty())
     return;
 
   CreateUpdaterIfNeeded();
 
   gfx::Rect content_rect = ScrollbarLayerRectToContentRect(
       gfx::Rect(scrollbar_->location(), bounds()));
   UpdatePart(back_track_updater_.get(),
              back_track_.get(),
              content_rect,
-             queue,
-             stats);
+             queue);
   if (fore_track_ && fore_track_updater_) {
     UpdatePart(fore_track_updater_.get(),
                fore_track_.get(),
                content_rect,
-               queue,
-               stats);
+               queue);
   }
 
   // Consider the thumb to be at the origin when painting.
   gfx::Rect thumb_rect = geometry_->thumbRect(scrollbar_.get());
   thumb_size_ = thumb_rect.size();
   gfx::Rect origin_thumb_rect =
       ScrollbarLayerRectToContentRect(gfx::Rect(thumb_rect.size()));
   if (!origin_thumb_rect.IsEmpty()) {
     UpdatePart(thumb_updater_.get(),
                thumb_.get(),
                origin_thumb_rect,
-               queue,
-               stats);
+               queue);
   }
 
   dirty_rect_ = gfx::RectF();
 }
 
 }  // namespace cc