Convert //cc from scoped_ptr to std::unique_ptr.

cc/trees/remote_channel_main.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 "cc/trees/remote_channel_main.h"
 
-#include "base/memory/scoped_ptr.h"
+#include <memory>
+
+#include "base/memory/ptr_util.h"
 #include "cc/proto/base_conversions.h"
 #include "cc/proto/compositor_message.pb.h"
 #include "cc/proto/compositor_message_to_impl.pb.h"
 #include "cc/proto/compositor_message_to_main.pb.h"
 #include "cc/proto/gfx_conversions.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/proxy_main.h"
 
 namespace cc {
 
-scoped_ptr<RemoteChannelMain> RemoteChannelMain::Create(
+std::unique_ptr<RemoteChannelMain> RemoteChannelMain::Create(
     RemoteProtoChannel* remote_proto_channel,
     ProxyMain* proxy_main,
     TaskRunnerProvider* task_runner_provider) {
-  return make_scoped_ptr(new RemoteChannelMain(remote_proto_channel, proxy_main,
-                                               task_runner_provider));
+  return base::WrapUnique(new RemoteChannelMain(
+      remote_proto_channel, proxy_main, task_runner_provider));
 }
 
 RemoteChannelMain::RemoteChannelMain(RemoteProtoChannel* remote_proto_channel,
                                      ProxyMain* proxy_main,
                                      TaskRunnerProvider* task_runner_provider)
     : remote_proto_channel_(remote_proto_channel),
       proxy_main_(proxy_main),
       task_runner_provider_(task_runner_provider),
       initialized_(false),
       weak_factory_(this) {
   DCHECK(remote_proto_channel_);
   DCHECK(proxy_main_);
   DCHECK(task_runner_provider_);
   DCHECK(task_runner_provider_->IsMainThread());
   remote_proto_channel_->SetProtoReceiver(this);
 }
 
 RemoteChannelMain::~RemoteChannelMain() {
   DCHECK(task_runner_provider_->IsMainThread());
   DCHECK(!initialized_);
 
   remote_proto_channel_->SetProtoReceiver(nullptr);
 }
 
 void RemoteChannelMain::OnProtoReceived(
-    scoped_ptr<proto::CompositorMessage> proto) {
+    std::unique_ptr<proto::CompositorMessage> proto) {
   DCHECK(task_runner_provider_->IsMainThread());
   DCHECK(proto->has_to_main());
 
   HandleProto(proto->to_main());
 }
 
 void RemoteChannelMain::UpdateTopControlsStateOnImpl(
     TopControlsState constraints,
     TopControlsState current,
     bool animate) {}
@@ skipping 124 matching lines @@
   // behaviour in the threaded compositor.
   MainThreadTaskRunner()->PostTask(
       FROM_HERE, base::Bind(&RemoteChannelMain::DidCommitAndDrawFrame,
                             weak_factory_.GetWeakPtr()));
 
   completion->Signal();
 }
 
 void RemoteChannelMain::SynchronouslyInitializeImpl(
     LayerTreeHost* layer_tree_host,
-    scoped_ptr<BeginFrameSource> external_begin_frame_source) {
+    std::unique_ptr<BeginFrameSource> external_begin_frame_source) {
   DCHECK(!initialized_);
 
   proto::CompositorMessage proto;
   proto::CompositorMessageToImpl* to_impl_proto = proto.mutable_to_impl();
   to_impl_proto->set_message_type(
       proto::CompositorMessageToImpl::INITIALIZE_IMPL);
   proto::InitializeImpl* initialize_impl_proto =
       to_impl_proto->mutable_initialize_impl_message();
   proto::LayerTreeSettings* settings_proto =
       initialize_impl_proto->mutable_layer_tree_settings();
@@ skipping 25 matching lines @@
   DCHECK(proto.has_message_type());
 
   switch (proto.message_type()) {
     case proto::CompositorMessageToMain::UNKNOWN:
       NOTIMPLEMENTED() << "Ignoring message proto of unknown type";
       break;
     case proto::CompositorMessageToMain::BEGIN_MAIN_FRAME: {
       VLOG(1) << "Received BeginMainFrame request from client.";
       const proto::BeginMainFrame& begin_main_frame_message =
           proto.begin_main_frame_message();
-      scoped_ptr<BeginMainFrameAndCommitState> begin_main_frame_state;
+      std::unique_ptr<BeginMainFrameAndCommitState> begin_main_frame_state;
       begin_main_frame_state.reset(new BeginMainFrameAndCommitState);
       begin_main_frame_state->FromProtobuf(
           begin_main_frame_message.begin_main_frame_state());
       proxy_main_->BeginMainFrame(std::move(begin_main_frame_state));
     } break;
   }
 }
 
 void RemoteChannelMain::DidCommitAndDrawFrame() {
   proxy_main_->DidCommitAndDrawFrame();
   DidCompleteSwapBuffers();
 }
 
 void RemoteChannelMain::DidCompleteSwapBuffers() {
   proxy_main_->DidCompleteSwapBuffers();
 }
 
 base::SingleThreadTaskRunner* RemoteChannelMain::MainThreadTaskRunner() const {
   return task_runner_provider_->MainThreadTaskRunner();
 }
 
 }  // namespace cc