Update from https://crrev.com/303153

cc/resources/picture_pile_impl.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 <algorithm>
 #include <limits>
 
 #include "base/debug/trace_event.h"
 #include "cc/base/region.h"
 #include "cc/debug/debug_colors.h"
@@ skipping 19 matching lines @@
 }
 
 PicturePileImpl::PicturePileImpl(const PicturePileBase* other)
     : PicturePileBase(other),
       likely_to_be_used_for_transform_animation_(false) {
 }
 
 PicturePileImpl::~PicturePileImpl() {
 }
 
-void PicturePileImpl::RasterDirect(
-    SkCanvas* canvas,
-    const gfx::Rect& canvas_rect,
-    float contents_scale,
-    RenderingStatsInstrumentation* rendering_stats_instrumentation) const {
+void PicturePileImpl::RasterDirect(SkCanvas* canvas,
+                                   const gfx::Rect& canvas_rect,
+                                   float contents_scale) const {
   RasterCommon(canvas,
                NULL,
                canvas_rect,
                contents_scale,
-               rendering_stats_instrumentation,
                false);
 }
 
-void PicturePileImpl::RasterForAnalysis(
-    skia::AnalysisCanvas* canvas,
-    const gfx::Rect& canvas_rect,
-    float contents_scale,
-    RenderingStatsInstrumentation* stats_instrumentation) const {
-  RasterCommon(
-      canvas, canvas, canvas_rect, contents_scale, stats_instrumentation, true);
+void PicturePileImpl::RasterForAnalysis(skia::AnalysisCanvas* canvas,
+                                        const gfx::Rect& canvas_rect,
+                                        float contents_scale) const {
+  RasterCommon(canvas, canvas, canvas_rect, contents_scale, true);
 }
 
-void PicturePileImpl::PlaybackToCanvas(
-    SkCanvas* canvas,
-    const gfx::Rect& canvas_rect,
-    float contents_scale,
-    RenderingStatsInstrumentation* rendering_stats_instrumentation) const {
+void PicturePileImpl::PlaybackToCanvas(SkCanvas* canvas,
+                                       const gfx::Rect& canvas_rect,
+                                       float contents_scale) const {
   canvas->discard();
   if (clear_canvas_with_debug_color_) {
     // Any non-painted areas in the content bounds will be left in this color.
     canvas->clear(DebugColors::NonPaintedFillColor());
   }
 
   // If this picture has opaque contents, it is guaranteeing that it will
   // draw an opaque rect the size of the layer.  If it is not, then we must
   // clear this canvas ourselves.
   if (contents_opaque_ || contents_fill_bounds_completely_) {
@@ skipping 41 matching lines @@
     TRACE_EVENT_INSTANT0("cc", "SkCanvas::clear", TRACE_EVENT_SCOPE_THREAD);
     // Clearing is about ~4x faster than drawing a rect even if the content
     // isn't covering a majority of the canvas.
     canvas->clear(SK_ColorTRANSPARENT);
   }
 
   RasterCommon(canvas,
                NULL,
                canvas_rect,
                contents_scale,
-               rendering_stats_instrumentation,
                false);
 }
 
 void PicturePileImpl::CoalesceRasters(const gfx::Rect& canvas_rect,
                                       const gfx::Rect& content_rect,
                                       float contents_scale,
                                       PictureRegionMap* results) const {
   DCHECK(results);
   // Rasterize the collection of relevant picture piles.
   gfx::Rect layer_rect = gfx::ScaleToEnclosingRect(
@@ skipping 83 matching lines @@
     clip_region->Subtract(content_clip);
     last_content_rect = content_clip;
   }
 }
 
 void PicturePileImpl::RasterCommon(
     SkCanvas* canvas,
     SkDrawPictureCallback* callback,
     const gfx::Rect& canvas_rect,
     float contents_scale,
-    RenderingStatsInstrumentation* rendering_stats_instrumentation,
     bool is_analysis) const {
   DCHECK(contents_scale >= min_contents_scale_);
 
   canvas->translate(-canvas_rect.x(), -canvas_rect.y());
   gfx::Rect content_tiling_rect = gfx::ToEnclosingRect(
       gfx::ScaleRect(gfx::Rect(tiling_.tiling_size()), contents_scale));
   content_tiling_rect.Intersect(canvas_rect);
 
   canvas->clipRect(gfx::RectToSkRect(content_tiling_rect),
                    SkRegion::kIntersect_Op);
@@ skipping 15 matching lines @@
     Region negated_clip_region = it->second;
 
 #ifndef NDEBUG
     Region positive_clip = content_tiling_rect;
     positive_clip.Subtract(negated_clip_region);
     // Make sure we never rasterize the same region twice.
     DCHECK(!total_clip.Intersects(positive_clip));
     total_clip.Union(positive_clip);
 #endif  // NDEBUG
 
-    base::TimeDelta best_duration = base::TimeDelta::Max();
     int repeat_count = std::max(1, slow_down_raster_scale_factor_for_debug_);
-    int rasterized_pixel_count = 0;
 
-    for (int j = 0; j < repeat_count; ++j) {
-      base::TimeTicks start_time;
-      if (rendering_stats_instrumentation)
-        start_time = rendering_stats_instrumentation->StartRecording();
-
-      rasterized_pixel_count = picture->Raster(
-          canvas, callback, negated_clip_region, contents_scale);
-
-      if (rendering_stats_instrumentation) {
-        base::TimeDelta duration =
-            rendering_stats_instrumentation->EndRecording(start_time);
-        best_duration = std::min(best_duration, duration);
-      }
-    }
-
-    if (rendering_stats_instrumentation) {
-      if (is_analysis) {
-        rendering_stats_instrumentation->AddAnalysis(best_duration,
-                                                     rasterized_pixel_count);
-      } else {
-        rendering_stats_instrumentation->AddRaster(best_duration,
-                                                   rasterized_pixel_count);
-      }
-    }
+    for (int j = 0; j < repeat_count; ++j)
+      picture->Raster(canvas, callback, negated_clip_region, contents_scale);
   }
 
 #ifndef NDEBUG
   // Fill the clip with debug color. This allows us to
   // distinguish between non painted areas and problems with missing
   // pictures.
   SkPaint paint;
   for (Region::Iterator it(total_clip); it.has_rect(); it.next())
     canvas->clipRect(gfx::RectToSkRect(it.rect()), SkRegion::kDifference_Op);
   paint.setColor(DebugColors::MissingPictureFillColor());
   paint.setXfermodeMode(SkXfermode::kSrc_Mode);
   canvas->drawPaint(paint);
 #endif  // NDEBUG
 }
 
 skia::RefPtr<SkPicture> PicturePileImpl::GetFlattenedPicture() {
   TRACE_EVENT0("cc", "PicturePileImpl::GetFlattenedPicture");
 
   gfx::Rect tiling_rect(tiling_.tiling_size());
   SkPictureRecorder recorder;
   SkCanvas* canvas =
       recorder.beginRecording(tiling_rect.width(), tiling_rect.height());
   if (!tiling_rect.IsEmpty())
-    PlaybackToCanvas(canvas, tiling_rect, 1.0, NULL);
+    PlaybackToCanvas(canvas, tiling_rect, 1.0);
   skia::RefPtr<SkPicture> picture = skia::AdoptRef(recorder.endRecording());
 
   return picture;
 }
 
 void PicturePileImpl::PerformSolidColorAnalysis(
     const gfx::Rect& content_rect,
     float contents_scale,
-    RasterSource::SolidColorAnalysis* analysis,
-    RenderingStatsInstrumentation* stats_instrumentation) const {
+    RasterSource::SolidColorAnalysis* analysis) const {
   DCHECK(analysis);
   TRACE_EVENT0("cc", "PicturePileImpl::PerformSolidColorAnalysis");
 
   gfx::Rect layer_rect = gfx::ScaleToEnclosingRect(
       content_rect, 1.0f / contents_scale);
 
   layer_rect.Intersect(gfx::Rect(tiling_.tiling_size()));
 
   skia::AnalysisCanvas canvas(layer_rect.width(), layer_rect.height());
 
-  RasterForAnalysis(&canvas, layer_rect, 1.0f, stats_instrumentation);
+  RasterForAnalysis(&canvas, layer_rect, 1.0f);
 
   analysis->is_solid_color = canvas.GetColorIfSolid(&analysis->solid_color);
 }
 
 void PicturePileImpl::GatherPixelRefs(
     const gfx::Rect& content_rect,
     float contents_scale,
     std::vector<SkPixelRef*>* pixel_refs) const {
   DCHECK_EQ(0u, pixel_refs->size());
   for (PixelRefIterator iter(content_rect, contents_scale, this); iter;
@@ skipping 68 matching lines @@
        ++it) {
     const Picture* picture = it->second.GetPicture();
     if (picture && (processed_pictures.count(picture) == 0)) {
       picture->EmitTraceSnapshot();
       processed_pictures.insert(picture);
     }
   }
 }
 
 }  // namespace cc