cc: Remove all traces of SkPicture cloning.

cc/resources/picture_pile_base.cc

 // Copyright 2013 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_base.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 54 matching lines @@
       slow_down_raster_scale_factor_for_debug_(
           other->slow_down_raster_scale_factor_for_debug_),
       contents_opaque_(other->contents_opaque_),
       contents_fill_bounds_completely_(other->contents_fill_bounds_completely_),
       show_debug_picture_borders_(other->show_debug_picture_borders_),
       clear_canvas_with_debug_color_(other->clear_canvas_with_debug_color_),
       has_any_recordings_(other->has_any_recordings_),
       has_text_(other->has_text_) {
 }
 
-PicturePileBase::PicturePileBase(const PicturePileBase* other,
-                                 unsigned thread_index)
-    : tiling_(other->tiling_),
-      recorded_viewport_(other->recorded_viewport_),
-      min_contents_scale_(other->min_contents_scale_),
-      tile_grid_info_(other->tile_grid_info_),
-      background_color_(other->background_color_),
-      slow_down_raster_scale_factor_for_debug_(
-          other->slow_down_raster_scale_factor_for_debug_),
-      contents_opaque_(other->contents_opaque_),
-      contents_fill_bounds_completely_(other->contents_fill_bounds_completely_),
-      show_debug_picture_borders_(other->show_debug_picture_borders_),
-      clear_canvas_with_debug_color_(other->clear_canvas_with_debug_color_),
-      has_any_recordings_(other->has_any_recordings_),
-      has_text_(other->has_text_) {
-  for (PictureMap::const_iterator it = other->picture_map_.begin();
-       it != other->picture_map_.end();
-       ++it) {
-    picture_map_[it->first] = it->second.CloneForThread(thread_index);
-  }
-}
-
 PicturePileBase::~PicturePileBase() {
 }
 
 void PicturePileBase::SetMinContentsScale(float min_contents_scale) {
   DCHECK(min_contents_scale);
   if (min_contents_scale_ == min_contents_scale)
     return;
 
   // Picture contents are played back scaled. When the final contents scale is
   // less than 1 (i.e. low res), then multiple recorded pixels will be used
@@ skipping 77 matching lines @@
        ++tile_iter) {
     PictureMap::const_iterator map_iter = picture_map_.find(tile_iter.index());
     if (map_iter == picture_map_.end())
       return false;
     if (!map_iter->second.GetPicture())
       return false;
   }
   return true;
 }
 
-gfx::Rect PicturePileBase::PaddedRect(const PictureMapKey& key) {
+gfx::Rect PicturePileBase::PaddedRect(const PictureMapKey& key) const {
   gfx::Rect tile = tiling_.TileBounds(key.first, key.second);
   return PadRect(tile);
 }
 
-gfx::Rect PicturePileBase::PadRect(const gfx::Rect& rect) {
+gfx::Rect PicturePileBase::PadRect(const gfx::Rect& rect) const {
   gfx::Rect padded_rect = rect;
   padded_rect.Inset(
       -buffer_pixels(), -buffer_pixels(), -buffer_pixels(), -buffer_pixels());
   return padded_rect;
 }
 
 void PicturePileBase::AsValueInto(base::debug::TracedValue* pictures) const {
   gfx::Rect tiling_rect(tiling_.tiling_size());
-  std::set<void*> appended_pictures;
+  std::set<const void*> appended_pictures;
   bool include_borders = true;
   for (TilingData::Iterator tile_iter(&tiling_, tiling_rect, include_borders);
        tile_iter;
        ++tile_iter) {
     PictureMap::const_iterator map_iter = picture_map_.find(tile_iter.index());
     if (map_iter == picture_map_.end())
       continue;
 
-    Picture* picture = map_iter->second.GetPicture();
+    const Picture* picture = map_iter->second.GetPicture();
     if (picture && (appended_pictures.count(picture) == 0)) {
       appended_pictures.insert(picture);
       TracedValue::AppendIDRef(picture, pictures);
     }
   }
 }
 
 PicturePileBase::PictureInfo::PictureInfo() : last_frame_number_(0) {}
 
 PicturePileBase::PictureInfo::~PictureInfo() {}
@@ skipping 27 matching lines @@
   // threshold).
   return !picture_ &&
          ((distance_to_visible <= kFrequentInvalidationDistanceThreshold) ||
           (GetInvalidationFrequency() < kInvalidationFrequencyThreshold));
 }
 
 void PicturePileBase::PictureInfo::SetPicture(scoped_refptr<Picture> picture) {
   picture_ = picture;
 }
 
-Picture* PicturePileBase::PictureInfo::GetPicture() const {
+const Picture* PicturePileBase::PictureInfo::GetPicture() const {
   return picture_.get();
 }
 
-PicturePileBase::PictureInfo PicturePileBase::PictureInfo::CloneForThread(
-    int thread_index) const {
-  PictureInfo info = *this;
-  if (picture_.get())
-    info.picture_ = picture_->GetCloneForDrawingOnThread(thread_index);
-  return info;
-}
-
 float PicturePileBase::PictureInfo::GetInvalidationFrequency() const {
   return invalidation_history_.count() /
          static_cast<float>(INVALIDATION_FRAMES_TRACKED);
 }
 
 }  // namespace cc