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

content/renderer/gpu/render_widget_compositor.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/gpu/render_widget_compositor.h"
 
 #include <stddef.h>
 #include <limits>
 #include <string>
 #include <utility>
@@ skipping 186 matching lines @@
               "mismatching enums: SHOWN");
 
 static cc::TopControlsState ConvertTopControlsState(
     WebTopControlsState state) {
   return static_cast<cc::TopControlsState>(state);
 }
 
 }  // 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;
 }
 
 RenderWidgetCompositor::RenderWidgetCompositor(
     RenderWidgetCompositorDelegate* delegate,
     CompositorDependencies* compositor_deps)
     : num_failed_recreate_attempts_(0),
       delegate_(delegate),
@@ skipping 254 matching lines @@
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager =
       compositor_deps_->GetGpuMemoryBufferManager();
   cc::TaskGraphRunner* task_graph_runner =
       compositor_deps_->GetTaskGraphRunner();
 
   bool use_remote_compositing = cmd->HasSwitch(switches::kUseRemoteCompositing);
 
   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();
   }
 
   cc::LayerTreeHost::InitParams params;
   params.client = this;
   params.shared_bitmap_manager = shared_bitmap_manager;
   params.gpu_memory_buffer_manager = gpu_memory_buffer_manager;
   params.settings = &settings;
   params.task_graph_runner = task_graph_runner;
@@ skipping 41 matching lines @@
 
 void RenderWidgetCompositor::SetNeedsRedrawRect(gfx::Rect damage_rect) {
   layer_tree_host_->SetNeedsRedrawRect(damage_rect);
 }
 
 void RenderWidgetCompositor::SetNeedsForcedRedraw() {
   layer_tree_host_->SetNextCommitForcesRedraw();
   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));
 }
 
 int RenderWidgetCompositor::GetSourceFrameNumber() const {
   return layer_tree_host_->source_frame_number();
 }
 
 void RenderWidgetCompositor::SetNeedsUpdateLayers() {
   layer_tree_host_->SetNeedsUpdateLayers();
 }
 
 void RenderWidgetCompositor::SetNeedsCommit() {
   layer_tree_host_->SetNeedsCommit();
 }
 
 void RenderWidgetCompositor::NotifyInputThrottledUntilCommit() {
   layer_tree_host_->NotifyInputThrottledUntilCommit();
 }
 
 const cc::Layer* RenderWidgetCompositor::GetRootLayer() const {
   return layer_tree_host_->root_layer();
 }
 
 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));
 }
 
 void RenderWidgetCompositor::setRootLayer(const blink::WebLayer& layer) {
   layer_tree_host_->SetRootLayer(
       static_cast<const cc_blink::WebLayerImpl*>(&layer)->layer());
 }
 
 void RenderWidgetCompositor::clearRootLayer() {
   layer_tree_host_->SetRootLayer(scoped_refptr<cc::Layer>());
@@ skipping 173 matching lines @@
 void RenderWidgetCompositor::setHaveScrollEventHandlers(bool has_handlers) {
   layer_tree_host_->SetHaveScrollEventHandlers(has_handlers);
 }
 
 bool RenderWidgetCompositor::haveScrollEventHandlers() const {
   return layer_tree_host_->have_scroll_event_handlers();
 }
 
 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());
   }
 }
 
 bool RenderWidgetCompositor::CompositeIsSynchronous() const {
   return !compositor_deps_->GetCompositorImplThreadTaskRunner().get() &&
          !layer_tree_host_->settings().single_thread_proxy_scheduler;
 }
@@ skipping 145 matching lines @@
 
 void RenderWidgetCompositor::RequestNewOutputSurface() {
   // If the host is closing, then no more compositing is possible.  This
   // prevents shutdown races between handling the close message and
   // the CreateOutputSurface task.
   if (delegate_->IsClosing())
     return;
 
   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) {
     DidFailToInitializeOutputSurface();
     return;
   }
 
   DCHECK_EQ(surface->capabilities().max_frames_pending, 1);
 
   layer_tree_host_->SetOutputSurface(std::move(surface));
@@ skipping 59 matching lines @@
 void RenderWidgetCompositor::SendCompositorProto(
     const cc::proto::CompositorMessage& proto) {
   int signed_size = proto.ByteSize();
   size_t unsigned_size = base::checked_cast<size_t>(signed_size);
   std::vector<uint8_t> serialized(unsigned_size);
   proto.SerializeToArray(serialized.data(), signed_size);
   delegate_->ForwardCompositorProto(serialized);
 }
 
 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));
 }
 
 void RenderWidgetCompositor::SetSurfaceIdNamespace(
     uint32_t surface_id_namespace) {
   layer_tree_host_->set_surface_id_namespace(surface_id_namespace);
 }
 
 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)) {
     LOG(ERROR) << "Unable to parse compositor proto.";
     return;
   }
 
   remote_proto_channel_receiver_->OnProtoReceived(std::move(deserialized));
 }
 
@@ skipping 76 matching lines @@
 #endif
   return actual;
 }
 
 void RenderWidgetCompositor::SetPaintedDeviceScaleFactor(
     float device_scale) {
   layer_tree_host_->SetPaintedDeviceScaleFactor(device_scale);
 }
 
 }  // namespace content