Convert //content/renderer from scoped_ptr to std::unique_ptr

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 31 matching lines @@
   gfx::Rect layer_rect;
   sk_sp<SkPicture> picture;
 };
 
 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));
+  std::unique_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(
+std::unique_ptr<base::Value> ParsePictureArg(v8::Isolate* isolate,
+                                             v8::Local<v8::Value> arg) {
+  std::unique_ptr<content::V8ValueConverter> converter(
       content::V8ValueConverter::create());
-  return scoped_ptr<base::Value>(
+  return std::unique_ptr<base::Value>(
       converter->FromV8Value(arg, isolate->GetCurrentContext()));
 }
 
-scoped_ptr<Picture> CreatePictureFromEncodedString(const std::string& encoded) {
+std::unique_ptr<Picture> CreatePictureFromEncodedString(
+    const std::string& encoded) {
   std::string decoded;
   base::Base64Decode(encoded, &decoded);
   SkMemoryStream stream(decoded.data(), decoded.size());
 
   sk_sp<SkPicture> skpicture =
       SkPicture::MakeFromStream(&stream, &DecodeBitmap);
   if (!skpicture)
     return nullptr;
 
-  scoped_ptr<Picture> picture(new Picture);
+  std::unique_ptr<Picture> picture(new Picture);
   picture->layer_rect = gfx::SkIRectToRect(skpicture->cullRect().roundOut());
   picture->picture = 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);
+std::unique_ptr<Picture> ParsePictureStr(v8::Isolate* isolate,
+                                         v8::Local<v8::Value> arg) {
+  std::unique_ptr<base::Value> picture_value = ParsePictureArg(isolate, arg);
   if (!picture_value)
     return nullptr;
   // Decode the picture from base64.
   std::string encoded;
   if (!picture_value->GetAsString(&encoded))
     return nullptr;
   return CreatePictureFromEncodedString(encoded);
 }
 
-scoped_ptr<Picture> ParsePictureHash(v8::Isolate* isolate,
-                                     v8::Local<v8::Value> arg) {
-  scoped_ptr<base::Value> picture_value = ParsePictureArg(isolate, arg);
+std::unique_ptr<Picture> ParsePictureHash(v8::Isolate* isolate,
+                                          v8::Local<v8::Value> arg) {
+  std::unique_ptr<base::Value> picture_value = ParsePictureArg(isolate, arg);
   if (!picture_value)
     return nullptr;
   const base::DictionaryValue* value = nullptr;
   if (!picture_value->GetAsDictionary(&value))
     return nullptr;
   // Decode the picture from base64.
   std::string encoded;
   if (!value->GetString("skp64", &encoded))
     return nullptr;
   return CreatePictureFromEncodedString(encoded);
@@ skipping 63 matching lines @@
       .SetMethod("getOpTimings", &SkiaBenchmarking::GetOpTimings)
       .SetMethod("getInfo", &SkiaBenchmarking::GetInfo);
 }
 
 void SkiaBenchmarking::Rasterize(gin::Arguments* args) {
   v8::Isolate* isolate = args->isolate();
   if (args->PeekNext().IsEmpty())
     return;
   v8::Local<v8::Value> picture_handle;
   args->GetNext(&picture_handle);
-  scoped_ptr<Picture> picture = ParsePictureHash(isolate, picture_handle);
+  std::unique_ptr<Picture> picture = ParsePictureHash(isolate, picture_handle);
   if (!picture.get())
     return;
 
   double scale = 1.0;
   gfx::Rect clip_rect(picture->layer_rect);
   int stop_index = -1;
   bool overdraw = false;
 
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   if (!args->PeekNext().IsEmpty()) {
     v8::Local<v8::Value> params;
     args->GetNext(&params);
-    scoped_ptr<content::V8ValueConverter> converter(
+    std::unique_ptr<content::V8ValueConverter> converter(
         content::V8ValueConverter::create());
-    scoped_ptr<base::Value> params_value(
+    std::unique_ptr<base::Value> params_value(
         converter->FromV8Value(params, context));
 
     const base::DictionaryValue* params_dict = NULL;
     if (params_value.get() && params_value->GetAsDictionary(&params_dict)) {
       params_dict->GetDouble("scale", &scale);
       params_dict->GetInteger("stop", &stop_index);
       params_dict->GetBoolean("overdraw", &overdraw);
 
       const base::Value* clip_value = NULL;
       if (params_dict->Get("clip", &clip_value))
@@ skipping 48 matching lines @@
 
   args->Return(result);
 }
 
 void SkiaBenchmarking::GetOps(gin::Arguments* args) {
   v8::Isolate* isolate = args->isolate();
   if (args->PeekNext().IsEmpty())
     return;
   v8::Local<v8::Value> picture_handle;
   args->GetNext(&picture_handle);
-  scoped_ptr<Picture> picture = ParsePictureHash(isolate, picture_handle);
+  std::unique_ptr<Picture> picture = ParsePictureHash(isolate, picture_handle);
   if (!picture.get())
     return;
 
   SkCanvas canvas(picture->layer_rect.width(), picture->layer_rect.height());
   skia::BenchmarkingCanvas benchmarking_canvas(&canvas);
   picture->picture->playback(&benchmarking_canvas);
 
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
-  scoped_ptr<content::V8ValueConverter> converter(
+  std::unique_ptr<content::V8ValueConverter> converter(
       content::V8ValueConverter::create());
 
   args->Return(converter->ToV8Value(&benchmarking_canvas.Commands(), context));
 }
 
 void SkiaBenchmarking::GetOpTimings(gin::Arguments* args) {
   v8::Isolate* isolate = args->isolate();
   if (args->PeekNext().IsEmpty())
     return;
   v8::Local<v8::Value> picture_handle;
   args->GetNext(&picture_handle);
-  scoped_ptr<Picture> picture = ParsePictureHash(isolate, picture_handle);
+  std::unique_ptr<Picture> picture = ParsePictureHash(isolate, picture_handle);
   if (!picture.get())
     return;
 
   gfx::Rect bounds = picture->layer_rect;
 
   // Measure the total time by drawing straight into a bitmap-backed canvas.
   SkBitmap bitmap;
   bitmap.allocN32Pixels(bounds.width(), bounds.height());
   SkCanvas bitmap_canvas(bitmap);
   bitmap_canvas.clear(SK_ColorTRANSPARENT);
@@ skipping 20 matching lines @@
 
   args->Return(result);
 }
 
 void SkiaBenchmarking::GetInfo(gin::Arguments* args) {
   v8::Isolate* isolate = args->isolate();
   if (args->PeekNext().IsEmpty())
     return;
   v8::Local<v8::Value> picture_handle;
   args->GetNext(&picture_handle);
-  scoped_ptr<Picture> picture = ParsePictureStr(isolate, picture_handle);
+  std::unique_ptr<Picture> picture = ParsePictureStr(isolate, picture_handle);
   if (!picture.get())
     return;
 
   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