Convert //components/[o-t]* from scoped_ptr to std::unique_ptr

components/test_runner/pixel_dump.cc

 // Copyright 2016 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 "components/test_runner/pixel_dump.h"
 
+#include <memory>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "components/test_runner/layout_test_runtime_flags.h"
 // FIXME: Including platform_canvas.h here is a layering violation.
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/platform/Platform.h"
 #include "third_party/WebKit/public/platform/WebCompositeAndReadbackAsyncCallback.h"
 #include "third_party/WebKit/public/platform/WebImage.h"
 #include "third_party/WebKit/public/platform/WebMockClipboard.h"
 #include "third_party/WebKit/public/platform/WebPoint.h"
@@ skipping 55 matching lines @@
   SkPaint paint;
   paint.setColor(0xFFFF0000);  // Fully opaque red
   paint.setStyle(SkPaint::kStroke_Style);
   paint.setFlags(SkPaint::kAntiAlias_Flag);
   paint.setStrokeWidth(1.0f);
   SkIRect rect;  // Bounding rect
   rect.set(wr.x, wr.y, wr.x + wr.width, wr.y + wr.height);
   canvas->drawIRect(rect, paint);
 }
 
-void CapturePixelsForPrinting(scoped_ptr<PixelsDumpRequest> dump_request) {
+void CapturePixelsForPrinting(std::unique_ptr<PixelsDumpRequest> dump_request) {
   dump_request->web_view->updateAllLifecyclePhases();
 
   blink::WebSize page_size_in_pixels = dump_request->web_view->size();
   blink::WebFrame* web_frame = dump_request->web_view->mainFrame();
 
   int page_count = web_frame->printBegin(page_size_in_pixels);
   int totalHeight = page_count * (page_size_in_pixels.height + 1) - 1;
 
   bool is_opaque = false;
   sk_sp<SkCanvas> canvas(skia::TryCreateBitmapCanvas(
@@ skipping 27 matching lines @@
   if (main_bitmap_.isNull()) {
     bitmap.deepCopyTo(&main_bitmap_);
     return;
   }
   SkCanvas canvas(main_bitmap_);
   canvas.drawBitmap(bitmap, popup_position_.x(), popup_position_.y());
   callback_.Run(main_bitmap_);
   delete this;
 }
 
-void DidCapturePixelsAsync(scoped_ptr<PixelsDumpRequest> dump_request,
+void DidCapturePixelsAsync(std::unique_ptr<PixelsDumpRequest> dump_request,
                            const SkBitmap& bitmap) {
   SkCanvas canvas(bitmap);
   DrawSelectionRect(*dump_request, &canvas);
   if (!dump_request->callback.is_null())
     dump_request->callback.Run(bitmap);
 }
 
 }  // namespace
 
 void DumpPixelsAsync(blink::WebView* web_view,
                      const LayoutTestRuntimeFlags& layout_test_runtime_flags,
                      float device_scale_factor_for_test,
                      const base::Callback<void(const SkBitmap&)>& callback) {
   TRACE_EVENT0("shell", "WebTestProxyBase::CapturePixelsAsync");
   DCHECK(!callback.is_null());
   DCHECK(!layout_test_runtime_flags.dump_drag_image());
 
-  scoped_ptr<PixelsDumpRequest> pixels_request(
+  std::unique_ptr<PixelsDumpRequest> pixels_request(
       new PixelsDumpRequest(web_view, layout_test_runtime_flags, callback));
 
   if (layout_test_runtime_flags.is_printing()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&CapturePixelsForPrinting,
                               base::Passed(std::move(pixels_request))));
     return;
   }
 
   CaptureCallback* capture_callback = new CaptureCallback(base::Bind(
@@ skipping 29 matching lines @@
 
   blink::WebImage image = static_cast<blink::WebMockClipboard*>(
                               blink::Platform::current()->clipboard())
                               ->readRawImage(blink::WebClipboard::Buffer());
   const SkBitmap& bitmap = image.getSkBitmap();
   SkAutoLockPixels autoLock(bitmap);
   callback.Run(bitmap);
 }
 
 }  // namespace test_runner