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

content/renderer/gpu/render_widget_compositor.cc

Index: content/renderer/gpu/render_widget_compositor.cc
diff --git a/content/renderer/gpu/render_widget_compositor.cc b/content/renderer/gpu/render_widget_compositor.cc
index f085fd5ed0588a6c06cbcecdcaf774cde30799f2..4fa758cb253f9247901d699d62a7f03f072483bb 100644
--- a/content/renderer/gpu/render_widget_compositor.cc
+++ b/content/renderer/gpu/render_widget_compositor.cc
@@ -204,11 +204,11 @@ static cc::TopControlsState ConvertTopControlsState(
 }  // namespace
 
 // static
-scoped_ptr<RenderWidgetCompositor> RenderWidgetCompositor::Create(
+std::unique_ptr<RenderWidgetCompositor> RenderWidgetCompositor::Create(
     RenderWidgetCompositorDelegate* delegate,
     float device_scale_factor,
     CompositorDependencies* compositor_deps) {
-  scoped_ptr<RenderWidgetCompositor> compositor(
+  std::unique_ptr<RenderWidgetCompositor> compositor(
       new RenderWidgetCompositor(delegate, compositor_deps));
   compositor->Initialize(device_scale_factor);
   return compositor;
@@ -483,7 +483,7 @@ void RenderWidgetCompositor::Initialize(float device_scale_factor) {
   if (use_remote_compositing)
     settings.use_external_begin_frame_source = false;
 
-  scoped_ptr<cc::BeginFrameSource> external_begin_frame_source;
+  std::unique_ptr<cc::BeginFrameSource> external_begin_frame_source;
   if (settings.use_external_begin_frame_source) {
     external_begin_frame_source = delegate_->CreateExternalBeginFrameSource();
   }
@@ -545,16 +545,16 @@ void RenderWidgetCompositor::SetNeedsForcedRedraw() {
   setNeedsAnimate();
 }
 
-scoped_ptr<cc::SwapPromiseMonitor>
+std::unique_ptr<cc::SwapPromiseMonitor>
 RenderWidgetCompositor::CreateLatencyInfoSwapPromiseMonitor(
     ui::LatencyInfo* latency) {
-  return scoped_ptr<cc::SwapPromiseMonitor>(
-      new cc::LatencyInfoSwapPromiseMonitor(
-          latency, layer_tree_host_.get(), NULL));
+  return std::unique_ptr<cc::SwapPromiseMonitor>(
+      new cc::LatencyInfoSwapPromiseMonitor(latency, layer_tree_host_.get(),
+                                            NULL));
 }
 
 void RenderWidgetCompositor::QueueSwapPromise(
-    scoped_ptr<cc::SwapPromise> swap_promise) {
+    std::unique_ptr<cc::SwapPromise> swap_promise) {
   layer_tree_host_->QueueSwapPromise(std::move(swap_promise));
 }
 
@@ -580,15 +580,15 @@ const cc::Layer* RenderWidgetCompositor::GetRootLayer() const {
 
 int RenderWidgetCompositor::ScheduleMicroBenchmark(
     const std::string& name,
-    scoped_ptr<base::Value> value,
-    const base::Callback<void(scoped_ptr<base::Value>)>& callback) {
+    std::unique_ptr<base::Value> value,
+    const base::Callback<void(std::unique_ptr<base::Value>)>& callback) {
   return layer_tree_host_->ScheduleMicroBenchmark(name, std::move(value),
                                                   callback);
 }
 
 bool RenderWidgetCompositor::SendMessageToMicroBenchmark(
     int id,
-    scoped_ptr<base::Value> value) {
+    std::unique_ptr<base::Value> value) {
   return layer_tree_host_->SendMessageToMicroBenchmark(id, std::move(value));
 }
 
@@ -782,9 +782,9 @@ bool RenderWidgetCompositor::haveScrollEventHandlers() const {
 
 void CompositeAndReadbackAsyncCallback(
     blink::WebCompositeAndReadbackAsyncCallback* callback,
-    scoped_ptr<cc::CopyOutputResult> result) {
+    std::unique_ptr<cc::CopyOutputResult> result) {
   if (result->HasBitmap()) {
-    scoped_ptr<SkBitmap> result_bitmap = result->TakeBitmap();
+    std::unique_ptr<SkBitmap> result_bitmap = result->TakeBitmap();
     callback->didCompositeAndReadback(*result_bitmap);
   } else {
     callback->didCompositeAndReadback(SkBitmap());
@@ -950,7 +950,7 @@ void RenderWidgetCompositor::RequestNewOutputSurface() {
 
   bool fallback =
       num_failed_recreate_attempts_ >= OUTPUT_SURFACE_RETRIES_BEFORE_FALLBACK;
-  scoped_ptr<cc::OutputSurface> surface(
+  std::unique_ptr<cc::OutputSurface> surface(
       delegate_->CreateOutputSurface(fallback));
 
   if (!surface) {
@@ -1030,8 +1030,10 @@ void RenderWidgetCompositor::SendCompositorProto(
 }
 
 void RenderWidgetCompositor::RecordFrameTimingEvents(
-    scoped_ptr<cc::FrameTimingTracker::CompositeTimingSet> composite_events,
-    scoped_ptr<cc::FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
+    std::unique_ptr<cc::FrameTimingTracker::CompositeTimingSet>
+        composite_events,
+    std::unique_ptr<cc::FrameTimingTracker::MainFrameTimingSet>
+        main_frame_events) {
   delegate_->RecordFrameTimingEvents(std::move(composite_events),
                                      std::move(main_frame_events));
 }
@@ -1045,7 +1047,7 @@ void RenderWidgetCompositor::OnHandleCompositorProto(
     const std::vector<uint8_t>& proto) {
   DCHECK(remote_proto_channel_receiver_);
 
-  scoped_ptr<cc::proto::CompositorMessage> deserialized(
+  std::unique_ptr<cc::proto::CompositorMessage> deserialized(
       new cc::proto::CompositorMessage);
   int signed_size = base::checked_cast<int>(proto.size());
   if (!deserialized->ParseFromArray(proto.data(), signed_size)) {