cc: Remove main thread rendering stats

cc/resources/picture_pile.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/resources/picture_pile.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
 #include "cc/base/region.h"
-#include "cc/debug/rendering_stats_instrumentation.h"
 #include "cc/resources/raster_worker_pool.h"
 #include "skia/ext/analysis_canvas.h"
 
 namespace {
 // Layout pixel buffer around the visible layer rect to record.  Any base
 // picture that intersects the visible layer rect expanded by this distance
 // will be recorded.
 const int kPixelDistanceToRecord = 8000;
 // We don't perform solid color analysis on images that have more than 10 skia
 // operations.
@@ skipping 135 matching lines @@
 
 bool PicturePile::UpdateAndExpandInvalidation(
     ContentLayerClient* painter,
     Region* invalidation,
     SkColor background_color,
     bool contents_opaque,
     bool contents_fill_bounds_completely,
     const gfx::Size& layer_size,
     const gfx::Rect& visible_layer_rect,
     int frame_number,
-    Picture::RecordingMode recording_mode,
-    RenderingStatsInstrumentation* stats_instrumentation) {
+    Picture::RecordingMode recording_mode) {
   background_color_ = background_color;
   contents_opaque_ = contents_opaque;
   contents_fill_bounds_completely_ = contents_fill_bounds_completely;
 
   bool updated = false;
 
   Region resize_invalidation;
   gfx::Size old_tiling_size = tiling_size();
   if (old_tiling_size != layer_size) {
     tiling_.SetTilingSize(layer_size);
@@ skipping 302 matching lines @@
     int repeat_count = std::max(1, slow_down_raster_scale_factor_for_debug_);
     scoped_refptr<Picture> picture;
 
     // Note: Currently, gathering of pixel refs when using a single
     // raster thread doesn't provide any benefit. This might change
     // in the future but we avoid it for now to reduce the cost of
     // Picture::Create.
     bool gather_pixel_refs = RasterWorkerPool::GetNumRasterThreads() > 1;
 
     {
-      base::TimeDelta best_duration = base::TimeDelta::Max();
       for (int i = 0; i < repeat_count; i++) {
-        base::TimeTicks start_time = stats_instrumentation->StartRecording();
         picture = Picture::Create(record_rect,
                                   painter,
                                   tile_grid_info_,
                                   gather_pixel_refs,
                                   recording_mode);
         // Note the '&&' with previous is-suitable state.
         // This means that once a picture-pile becomes unsuitable for gpu
         // rasterization due to some content, it will continue to be unsuitable
         // even if that content is replaced by gpu-friendly content.
         // This is an optimization to avoid iterating though all pictures in
         // the pile after each invalidation.
         is_suitable_for_gpu_rasterization_ &=
             picture->IsSuitableForGpuRasterization();
-        base::TimeDelta duration =
-            stats_instrumentation->EndRecording(start_time);
-        best_duration = std::min(duration, best_duration);
       }
-      int recorded_pixel_count =
-          picture->LayerRect().width() * picture->LayerRect().height();
-      stats_instrumentation->AddRecord(best_duration, recorded_pixel_count);
     }
 
     bool found_tile_for_recorded_picture = false;
 
     bool include_borders = true;
     for (TilingData::Iterator it(&tiling_, record_rect, include_borders); it;
          ++it) {
       const PictureMapKey& key = it.index();
       gfx::Rect tile = PaddedRect(key);
       if (record_rect.Contains(tile)) {
@@ skipping 55 matching lines @@
       return;
   }
   skia::AnalysisCanvas canvas(recorded_viewport_.width(),
                               recorded_viewport_.height());
   canvas.translate(-recorded_viewport_.x(), -recorded_viewport_.y());
   picture->Raster(&canvas, nullptr, Region(), 1.0f);
   is_solid_color_ = canvas.GetColorIfSolid(&solid_color_);
 }
 
 }  // namespace cc