cc: Remove all traces of SkPicture cloning.

cc/resources/picture.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.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
@@ skipping 71 matching lines @@
   return false;
 }
 
 }  // namespace
 
 scoped_refptr<Picture> Picture::Create(
     const gfx::Rect& layer_rect,
     ContentLayerClient* client,
     const SkTileGridFactory::TileGridInfo& tile_grid_info,
     bool gather_pixel_refs,
-    int num_raster_threads,
     RecordingMode recording_mode) {
   scoped_refptr<Picture> picture = make_scoped_refptr(new Picture(layer_rect));
 
   picture->Record(client, tile_grid_info, recording_mode);
   if (gather_pixel_refs)
     picture->GatherPixelRefs(tile_grid_info);
-  picture->CloneForDrawing(num_raster_threads);
 
   return picture;
 }
 
 Picture::Picture(const gfx::Rect& layer_rect)
   : layer_rect_(layer_rect),
     cell_size_(layer_rect.size()) {
   // Instead of recording a trace event for object creation here, we wait for
   // the picture to be recorded in Picture::Record.
 }
@@ skipping 75 matching lines @@
     picture_(picture),
     pixel_refs_(pixel_refs),
     cell_size_(layer_rect.size()) {
 }
 
 Picture::~Picture() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
     TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::Picture", this);
 }
 
-Picture* Picture::GetCloneForDrawingOnThread(unsigned thread_index) {
-  // We don't need clones to draw from multiple threads with SkRecord.
-  if (playback_) {
-    return this;
-  }
-
-  // SkPicture is not thread-safe to rasterize with, this returns a clone
-  // to rasterize with on a specific thread.
-  CHECK_GE(clones_.size(), thread_index);
-  return thread_index == clones_.size() ? this : clones_[thread_index].get();
-}
-
 bool Picture::IsSuitableForGpuRasterization() const {
   DCHECK(picture_);
 
   // TODO(alokp): SkPicture::suitableForGpuRasterization needs a GrContext.
   // Ideally this GrContext should be the same as that for rasterizing this
   // picture. But we are on the main thread while the rasterization context
   // may be on the compositor or raster thread.
   // SkPicture::suitableForGpuRasterization is not implemented yet.
   // Pass a NULL context for now and discuss with skia folks if the context
   // is really needed.
   return picture_->suitableForGpuRasterization(NULL);
 }
 
 bool Picture::HasText() const {
   DCHECK(picture_);
   return picture_->hasText();
 }
 
-void Picture::CloneForDrawing(int num_threads) {
-  TRACE_EVENT1("cc", "Picture::CloneForDrawing", "num_threads", num_threads);
-
-  // We don't need clones to draw from multiple threads with SkRecord.
-  if (playback_) {
-    return;
-  }
-
-  DCHECK(picture_);
-  DCHECK(clones_.empty());
-
-  // We can re-use this picture for one raster worker thread.
-  raster_thread_checker_.DetachFromThread();
-
-  if (num_threads > 1) {
-    for (int i = 0; i < num_threads - 1; i++) {
-      scoped_refptr<Picture> clone =
-          new Picture(skia::AdoptRef(picture_->clone()),
-                      layer_rect_,
-                      opaque_rect_,
-                      pixel_refs_);
-      clones_.push_back(clone);
-
-      clone->EmitTraceSnapshotAlias(this);
-      clone->raster_thread_checker_.DetachFromThread();
-    }
-  }
-}
-
 void Picture::Record(ContentLayerClient* painter,
                      const SkTileGridFactory::TileGridInfo& tile_grid_info,
                      RecordingMode recording_mode) {
   TRACE_EVENT2("cc",
                "Picture::Record",
                "data",
                AsTraceableRecordData(),
                "recording_mode",
                recording_mode);
 
@@ skipping 115 matching lines @@
     min_x = std::min(min_x, min.x());
     min_y = std::min(min_y, min.y());
     max_x = std::max(max_x, max.x());
     max_y = std::max(max_y, max.y());
   }
 
   min_pixel_cell_ = gfx::Point(min_x, min_y);
   max_pixel_cell_ = gfx::Point(max_x, max_y);
 }
 
-int Picture::Raster(
-    SkCanvas* canvas,
-    SkDrawPictureCallback* callback,
-    const Region& negated_content_region,
-    float contents_scale) {
-  if (!playback_)
-    DCHECK(raster_thread_checker_.CalledOnValidThread());
+int Picture::Raster(SkCanvas* canvas,
+                    SkDrawPictureCallback* callback,
+                    const Region& negated_content_region,
+                    float contents_scale) const {
   TRACE_EVENT_BEGIN1(
       "cc",
       "Picture::Raster",
       "data",
       AsTraceableRasterData(contents_scale));
 
   DCHECK(picture_);
 
   canvas->save();
 
@@ skipping 10 matching lines @@
   SkIRect bounds;
   canvas->getClipDeviceBounds(&bounds);
   canvas->restore();
   TRACE_EVENT_END1(
       "cc", "Picture::Raster",
       "num_pixels_rasterized", bounds.width() * bounds.height());
   return bounds.width() * bounds.height();
 }
 
 void Picture::Replay(SkCanvas* canvas) {
-  if (!playback_)
-    DCHECK(raster_thread_checker_.CalledOnValidThread());
   TRACE_EVENT_BEGIN0("cc", "Picture::Replay");
   DCHECK(picture_);
 
   if (playback_) {
     playback_->draw(canvas);
   } else {
     picture_->draw(canvas);
   }
   SkIRect bounds;
   canvas->getClipDeviceBounds(&bounds);
@@ skipping 166 matching lines @@
   scoped_refptr<base::debug::TracedValue> record_data =
       new base::debug::TracedValue();
   TracedValue::SetIDRef(this, record_data.get(), "picture_id");
   record_data->BeginArray("layer_rect");
   MathUtil::AddToTracedValue(layer_rect_, record_data.get());
   record_data->EndArray();
   return record_data;
 }
 
 }  // namespace cc