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

cc/trees/proxy_main.cc

 // Copyright 2015 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/proxy_main.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "base/trace_event/trace_event_synthetic_delay.h"
 #include "cc/animation/animation_events.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/swap_promise.h"
 #include "cc/trees/blocking_task_runner.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/remote_channel_main.h"
 #include "cc/trees/scoped_abort_remaining_swap_promises.h"
 #include "cc/trees/threaded_channel.h"
 
 namespace cc {
 
-scoped_ptr<ProxyMain> ProxyMain::CreateThreaded(
+std::unique_ptr<ProxyMain> ProxyMain::CreateThreaded(
     LayerTreeHost* layer_tree_host,
     TaskRunnerProvider* task_runner_provider) {
-  scoped_ptr<ProxyMain> proxy_main(
+  std::unique_ptr<ProxyMain> proxy_main(
       new ProxyMain(layer_tree_host, task_runner_provider));
   proxy_main->SetChannel(
       ThreadedChannel::Create(proxy_main.get(), task_runner_provider));
   return proxy_main;
 }
 
-scoped_ptr<ProxyMain> ProxyMain::CreateRemote(
+std::unique_ptr<ProxyMain> ProxyMain::CreateRemote(
     RemoteProtoChannel* remote_proto_channel,
     LayerTreeHost* layer_tree_host,
     TaskRunnerProvider* task_runner_provider) {
-  scoped_ptr<ProxyMain> proxy_main(
+  std::unique_ptr<ProxyMain> proxy_main(
       new ProxyMain(layer_tree_host, task_runner_provider));
   proxy_main->SetChannel(RemoteChannelMain::Create(
       remote_proto_channel, proxy_main.get(), task_runner_provider));
   return proxy_main;
 }
 
 ProxyMain::ProxyMain(LayerTreeHost* layer_tree_host,
                      TaskRunnerProvider* task_runner_provider)
     : layer_tree_host_(layer_tree_host),
       task_runner_provider_(task_runner_provider),
       layer_tree_host_id_(layer_tree_host->id()),
       max_requested_pipeline_stage_(NO_PIPELINE_STAGE),
       current_pipeline_stage_(NO_PIPELINE_STAGE),
       final_pipeline_stage_(NO_PIPELINE_STAGE),
       commit_waits_for_activation_(false),
       started_(false),
       defer_commits_(false) {
   TRACE_EVENT0("cc", "ProxyMain::ProxyMain");
   DCHECK(task_runner_provider_);
   DCHECK(IsMainThread());
 }
 
 ProxyMain::~ProxyMain() {
   TRACE_EVENT0("cc", "ProxyMain::~ProxyMain");
   DCHECK(IsMainThread());
   DCHECK(!started_);
 }
 
-void ProxyMain::SetChannel(scoped_ptr<ChannelMain> channel_main) {
+void ProxyMain::SetChannel(std::unique_ptr<ChannelMain> channel_main) {
   DCHECK(!channel_main_);
   channel_main_ = std::move(channel_main);
 }
 
 void ProxyMain::DidCompleteSwapBuffers() {
   DCHECK(IsMainThread());
   layer_tree_host_->DidCompleteSwapBuffers();
 }
 
 void ProxyMain::SetRendererCapabilities(
     const RendererCapabilities& capabilities) {
   DCHECK(IsMainThread());
   renderer_capabilities_ = capabilities;
 }
 
 void ProxyMain::BeginMainFrameNotExpectedSoon() {
   TRACE_EVENT0("cc", "ProxyMain::BeginMainFrameNotExpectedSoon");
   DCHECK(IsMainThread());
   layer_tree_host_->BeginMainFrameNotExpectedSoon();
 }
 
 void ProxyMain::DidCommitAndDrawFrame() {
   DCHECK(IsMainThread());
   layer_tree_host_->DidCommitAndDrawFrame();
 }
 
-void ProxyMain::SetAnimationEvents(scoped_ptr<AnimationEvents> events) {
+void ProxyMain::SetAnimationEvents(std::unique_ptr<AnimationEvents> events) {
   TRACE_EVENT0("cc", "ProxyMain::SetAnimationEvents");
   DCHECK(IsMainThread());
   layer_tree_host_->SetAnimationEvents(std::move(events));
 }
 
 void ProxyMain::DidLoseOutputSurface() {
   TRACE_EVENT0("cc", "ProxyMain::DidLoseOutputSurface");
   DCHECK(IsMainThread());
   layer_tree_host_->DidLoseOutputSurface();
 }
@@ skipping 16 matching lines @@
   renderer_capabilities_ = capabilities;
   layer_tree_host_->DidInitializeOutputSurface();
 }
 
 void ProxyMain::DidCompletePageScaleAnimation() {
   DCHECK(IsMainThread());
   layer_tree_host_->DidCompletePageScaleAnimation();
 }
 
 void ProxyMain::PostFrameTimingEventsOnMain(
-    scoped_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
-    scoped_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
+    std::unique_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
+    std::unique_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
   DCHECK(IsMainThread());
   layer_tree_host_->RecordFrameTimingEvents(std::move(composite_events),
                                             std::move(main_frame_events));
 }
 
 void ProxyMain::BeginMainFrame(
-    scoped_ptr<BeginMainFrameAndCommitState> begin_main_frame_state) {
+    std::unique_ptr<BeginMainFrameAndCommitState> begin_main_frame_state) {
   benchmark_instrumentation::ScopedBeginFrameTask begin_frame_task(
       benchmark_instrumentation::kDoBeginFrame,
       begin_main_frame_state->begin_frame_id);
 
   base::TimeTicks begin_main_frame_start_time = base::TimeTicks::Now();
 
   TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("cc.BeginMainFrame");
   DCHECK(IsMainThread());
   DCHECK_EQ(NO_PIPELINE_STAGE, current_pipeline_stage_);
 
@@ skipping 223 matching lines @@
   DCHECK(IsMainThread());
   return max_requested_pipeline_stage_ != NO_PIPELINE_STAGE;
 }
 
 void ProxyMain::MainThreadHasStoppedFlinging() {
   DCHECK(IsMainThread());
   channel_main_->MainThreadHasStoppedFlingingOnImpl();
 }
 
 void ProxyMain::Start(
-    scoped_ptr<BeginFrameSource> external_begin_frame_source) {
+    std::unique_ptr<BeginFrameSource> external_begin_frame_source) {
   DCHECK(IsMainThread());
   DCHECK(layer_tree_host_->IsThreaded() || layer_tree_host_->IsRemoteServer());
   DCHECK(channel_main_);
   DCHECK(!layer_tree_host_->settings().use_external_begin_frame_source ||
          external_begin_frame_source);
 
   // Create LayerTreeHostImpl.
   channel_main_->SynchronouslyInitializeImpl(
       layer_tree_host_, std::move(external_begin_frame_source));
 
@@ skipping 68 matching lines @@
     return false;
   channel_main_->SetNeedsCommitOnImpl();
   return true;
 }
 
 bool ProxyMain::IsMainThread() const {
   return task_runner_provider_->IsMainThread();
 }
 
 }  // namespace cc