Use sk_sp-based picture recording APIs in Blink

content/renderer/skia_benchmarking_extension.cc

 // Copyright (c) 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 "content/renderer/skia_benchmarking_extension.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/base64.h"
@@ skipping 22 matching lines @@
 #include "ui/gfx/skia_util.h"
 #include "v8/include/v8.h"
 
 namespace content {
 
 namespace {
 
 class Picture {
  public:
   gfx::Rect layer_rect;
   skia::RefPtr<SkPicture> picture;

[tomhudson, 2016/03/24 19:52:40]

We could change this to sk_sp<>?

[f(malita), 2016/03/24 20:22:41]

Good point, it's a local type.  Done.

 };
 
 bool DecodeBitmap(const void* buffer, size_t size, SkBitmap* bm) {
   const unsigned char* data = static_cast<const unsigned char*>(buffer);
   // Try PNG first.
   if (gfx::PNGCodec::Decode(data, size, bm))
     return true;
   // Try JPEG.
   scoped_ptr<SkBitmap> decoded_jpeg(gfx::JPEGCodec::Decode(data, size));
   if (decoded_jpeg) {
     *bm = *decoded_jpeg;
     return true;
   }
   return false;
 }
 
 scoped_ptr<base::Value> ParsePictureArg(v8::Isolate* isolate,
                                         v8::Local<v8::Value> arg) {
   scoped_ptr<content::V8ValueConverter> converter(
       content::V8ValueConverter::create());
   return scoped_ptr<base::Value>(
       converter->FromV8Value(arg, isolate->GetCurrentContext()));
 }
 
 scoped_ptr<Picture> CreatePictureFromEncodedString(const std::string& encoded) {
   std::string decoded;
   base::Base64Decode(encoded, &decoded);
   SkMemoryStream stream(decoded.data(), decoded.size());
 
-  SkPicture* skpicture = SkPicture::CreateFromStream(&stream, &DecodeBitmap);
+  sk_sp<SkPicture> skpicture =
+      SkPicture::MakeFromStream(&stream, &DecodeBitmap);
   if (!skpicture)
     return nullptr;
 
   scoped_ptr<Picture> picture(new Picture);
   picture->layer_rect = gfx::SkIRectToRect(skpicture->cullRect().roundOut());
-  picture->picture = skia::AdoptRef(skpicture);
+  picture->picture = skia::AdoptRef(std::move(skpicture));
   return picture;
 }
 
 scoped_ptr<Picture> ParsePictureStr(v8::Isolate* isolate,
                                     v8::Local<v8::Value> arg) {
   scoped_ptr<base::Value> picture_value = ParsePictureArg(isolate, arg);
   if (!picture_value)
     return nullptr;
   // Decode the picture from base64.
   std::string encoded;
@@ skipping 241 matching lines @@
   v8::Local<v8::Object> result = v8::Object::New(isolate);
   result->Set(v8::String::NewFromUtf8(isolate, "width"),
               v8::Number::New(isolate, picture->layer_rect.width()));
   result->Set(v8::String::NewFromUtf8(isolate, "height"),
               v8::Number::New(isolate, picture->layer_rect.height()));
 
   args->Return(result);
 }
 
 } // namespace content