cc: Remove all traces of SkPicture cloning.

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"
 #include "cc/resources/picture_pile_impl.h"
-#include "cc/resources/raster_worker_pool.h"
 #include "skia/ext/analysis_canvas.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkSize.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/skia_util.h"
 
 namespace cc {
 
-PicturePileImpl::ClonesForDrawing::ClonesForDrawing(
-    const PicturePileImpl* pile, int num_threads) {
-  for (int i = 0; i < num_threads; i++) {
-    scoped_refptr<PicturePileImpl> clone =
-        PicturePileImpl::CreateCloneForDrawing(pile, i);
-    clones_.push_back(clone);
-  }
-}
-
-PicturePileImpl::ClonesForDrawing::~ClonesForDrawing() {
-}
-
 scoped_refptr<PicturePileImpl> PicturePileImpl::Create() {
   return make_scoped_refptr(new PicturePileImpl);
 }
 
 scoped_refptr<PicturePileImpl> PicturePileImpl::CreateFromOther(
     const PicturePileBase* other) {
   return make_scoped_refptr(new PicturePileImpl(other));
 }
 
-scoped_refptr<PicturePileImpl> PicturePileImpl::CreateCloneForDrawing(
-    const PicturePileImpl* other, unsigned thread_index) {
-  return make_scoped_refptr(new PicturePileImpl(other, thread_index));
-}
-
-PicturePileImpl::PicturePileImpl()
-    : clones_for_drawing_(ClonesForDrawing(this, 0)) {
+PicturePileImpl::PicturePileImpl() {
 }
 
 PicturePileImpl::PicturePileImpl(const PicturePileBase* other)
-    : PicturePileBase(other),
-      clones_for_drawing_(ClonesForDrawing(
-                              this, RasterWorkerPool::GetNumRasterThreads())) {
-}
-
-PicturePileImpl::PicturePileImpl(
-    const PicturePileImpl* other, unsigned thread_index)
-    : PicturePileBase(other, thread_index),
-      clones_for_drawing_(ClonesForDrawing(this, 0)) {
+    : PicturePileBase(other) {
 }
 
 PicturePileImpl::~PicturePileImpl() {
 }
 
-PicturePileImpl* PicturePileImpl::GetCloneForDrawingOnThread(
-    unsigned thread_index) const {
-  CHECK_GT(clones_for_drawing_.clones_.size(), thread_index);
-  return clones_for_drawing_.clones_[thread_index].get();
-}
-
 void PicturePileImpl::RasterDirect(
     SkCanvas* canvas,
     const gfx::Rect& canvas_rect,
     float contents_scale,
     RenderingStatsInstrumentation* rendering_stats_instrumentation) {
   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) {
+    RenderingStatsInstrumentation* stats_instrumentation) const {
   RasterCommon(
       canvas, canvas, canvas_rect, contents_scale, stats_instrumentation, true);
 }
 
 void PicturePileImpl::RasterToBitmap(
     SkCanvas* canvas,
     const gfx::Rect& canvas_rect,
     float contents_scale,
-    RenderingStatsInstrumentation* rendering_stats_instrumentation) {
+    RenderingStatsInstrumentation* rendering_stats_instrumentation) 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 48 matching lines @@
                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) {
+                                      PictureRegionMap* results) const {
   DCHECK(results);
   // Rasterize the collection of relevant picture piles.
   gfx::Rect layer_rect = gfx::ScaleToEnclosingRect(
       content_rect, 1.f / contents_scale);
 
   // Make sure pictures don't overlap by keeping track of previous right/bottom.
   int min_content_left = -1;
   int min_content_top = -1;
   int last_row_index = -1;
   int last_col_index = -1;
@@ skipping 10 matching lines @@
   // ignores the transform). Intersect then can be written as subtracting the
   // negation of the region we're trying to intersect. Luckily, we know that all
   // of the rects will have to fit into |content_rect|, so we can start with
   // that and subtract chunk rects to get the region that we need to subtract
   // from the canvas. Then, we can use clipRect with difference op to subtract
   // each rect in the region.
   bool include_borders = true;
   for (TilingData::Iterator tile_iter(&tiling_, layer_rect, include_borders);
        tile_iter;
        ++tile_iter) {
-    PictureMap::iterator map_iter = picture_map_.find(tile_iter.index());
+    PictureMap::const_iterator map_iter = picture_map_.find(tile_iter.index());
     if (map_iter == picture_map_.end())
       continue;
-    PictureInfo& info = map_iter->second;
-    Picture* picture = info.GetPicture();
+    const PictureInfo& info = map_iter->second;
+    const Picture* picture = info.GetPicture();
     if (!picture)
       continue;
 
     // This is intentionally *enclosed* rect, so that the clip is aligned on
     // integral post-scale content pixels and does not extend past the edges
     // of the picture chunk's layer rect.  The min_contents_scale enforces that
     // enough buffer pixels have been added such that the enclosed rect
     // encompasses all invalidated pixels at any larger scale level.
     gfx::Rect chunk_rect = PaddedRect(tile_iter.index());
     gfx::Rect content_clip =
@@ skipping 42 matching lines @@
     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) {
+    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);
 
   PictureRegionMap picture_region_map;
   CoalesceRasters(
       canvas_rect, content_tiling_rect, contents_scale, &picture_region_map);
 
 #ifndef NDEBUG
   Region total_clip;
 #endif  // NDEBUG
 
   // Iterate the coalesced map and use each picture's region
   // to clip the canvas.
   for (PictureRegionMap::iterator it = picture_region_map.begin();
        it != picture_region_map.end();
        ++it) {
-    Picture* picture = it->first;
+    const Picture* picture = it->first;
     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
 
@@ skipping 47 matching lines @@
   SkPictureRecorder recorder;
   SkCanvas* canvas =
       recorder.beginRecording(tiling_rect.width(), tiling_rect.height());
   if (!tiling_rect.IsEmpty())
     RasterToBitmap(canvas, tiling_rect, 1.0, NULL);
   skia::RefPtr<SkPicture> picture = skia::AdoptRef(recorder.endRecording());
 
   return picture;
 }
 
-void PicturePileImpl::AnalyzeInRect(
-    const gfx::Rect& content_rect,
-    float contents_scale,
-    PicturePileImpl::Analysis* analysis) {
+void PicturePileImpl::AnalyzeInRect(const gfx::Rect& content_rect,
+                                    float contents_scale,
+                                    PicturePileImpl::Analysis* analysis) const {
   AnalyzeInRect(content_rect, contents_scale, analysis, NULL);
 }
 
 void PicturePileImpl::AnalyzeInRect(
     const gfx::Rect& content_rect,
     float contents_scale,
     PicturePileImpl::Analysis* analysis,
-    RenderingStatsInstrumentation* stats_instrumentation) {
+    RenderingStatsInstrumentation* stats_instrumentation) const {
   DCHECK(analysis);
   TRACE_EVENT0("cc", "PicturePileImpl::AnalyzeInRect");
 
   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());
 
@@ skipping 56 matching lines @@
       continue;
 
     processed_pictures_.insert(picture);
     pixel_ref_iterator_ = Picture::PixelRefIterator(layer_rect_, picture);
     if (pixel_ref_iterator_)
       break;
   }
 }
 
 void PicturePileImpl::DidBeginTracing() {
-  std::set<void*> processed_pictures;
+  std::set<const void*> processed_pictures;
   for (PictureMap::iterator it = picture_map_.begin();
        it != picture_map_.end();
        ++it) {
-    Picture* picture = it->second.GetPicture();
+    const Picture* picture = it->second.GetPicture();
     if (picture && (processed_pictures.count(picture) == 0)) {
       picture->EmitTraceSnapshot();
       processed_pictures.insert(picture);
     }
   }
 }
 
 }  // namespace cc