Switch to one-at-a-time SkPicture::clone interface

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 213 matching lines @@
     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) {
-    scoped_ptr<SkPicture[]> clones(new SkPicture[num_threads - 1]);
+    scoped_ptr<SkPicture* []> clones(new SkPicture* [num_threads - 1]);

[danakj, 2014/07/10 19:57:05]

This is an array of raw SkRefCnt pointers? Since skia won't adopt something like
skia::RefPtr I don't know what to suggest given this intended skia api. I just
wanted to say that this makes me super sad, cuz we can't immediately wrap the
raw pointers in RefPtr like this.

If this was more common I'd suggest a RefPtrVector similar to
ScopedPtrVector.....

[mtklein, 2014/07/10 20:09:51]

Why don't we rewrite this to just use the other existing clone method,
  SkPicture* SkPicture::clone() const;
?

This still lets us remove the default constructor and the copy constructor, and
allows Picture to wrap the SkPicture* in a skia::AdoptRef right away.

This means we also don't have to land the Skia-side CL adding void
SkPicture::clone(SkPicture* [], int).

     picture_->clone(&clones[0], num_threads - 1);
 
     for (int i = 0; i < num_threads - 1; i++) {
-      scoped_refptr<Picture> clone = make_scoped_refptr(
-          new Picture(skia::AdoptRef(new SkPicture(clones[i])),
-                      layer_rect_,
-                      opaque_rect_,
-                      pixel_refs_));
+      scoped_refptr<Picture> clone = make_scoped_refptr(new Picture(
+          skia::AdoptRef(clones[i]), 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,
@@ skipping 344 matching lines @@
 
 scoped_refptr<base::debug::ConvertableToTraceFormat>
     Picture::AsTraceableRecordData() const {
   scoped_ptr<base::DictionaryValue> record_data(new base::DictionaryValue());
   record_data->Set("picture_id", TracedValue::CreateIDRef(this).release());
   record_data->Set("layer_rect", MathUtil::AsValue(layer_rect_).release());
   return TracedValue::FromValue(record_data.release());
 }
 
 }  // namespace cc