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

cc/trees/proxy_impl.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_impl.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/auto_reset.h"
+#include "base/memory/ptr_util.h"
 #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/input/top_controls_manager.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
 #include "cc/scheduler/compositor_timing_history.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/task_runner_provider.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 
 namespace cc {
 
 namespace {
 
 // Measured in seconds.
 const double kSmoothnessTakesPriorityExpirationDelay = 0.25;
 
 unsigned int nextBeginFrameId = 0;
 
 }  // namespace
 
-scoped_ptr<ProxyImpl> ProxyImpl::Create(
+std::unique_ptr<ProxyImpl> ProxyImpl::Create(
     ChannelImpl* channel_impl,
     LayerTreeHost* layer_tree_host,
     TaskRunnerProvider* task_runner_provider,
-    scoped_ptr<BeginFrameSource> external_begin_frame_source) {
-  return make_scoped_ptr(new ProxyImpl(channel_impl, layer_tree_host,
-                                       task_runner_provider,
-                                       std::move(external_begin_frame_source)));
+    std::unique_ptr<BeginFrameSource> external_begin_frame_source) {
+  return base::WrapUnique(
+      new ProxyImpl(channel_impl, layer_tree_host, task_runner_provider,
+                    std::move(external_begin_frame_source)));
 }
 
-ProxyImpl::ProxyImpl(ChannelImpl* channel_impl,
-                     LayerTreeHost* layer_tree_host,
-                     TaskRunnerProvider* task_runner_provider,
-                     scoped_ptr<BeginFrameSource> external_begin_frame_source)
+ProxyImpl::ProxyImpl(
+    ChannelImpl* channel_impl,
+    LayerTreeHost* layer_tree_host,
+    TaskRunnerProvider* task_runner_provider,
+    std::unique_ptr<BeginFrameSource> external_begin_frame_source)
     : layer_tree_host_id_(layer_tree_host->id()),
       next_commit_waits_for_activation_(false),
       commit_completion_event_(nullptr),
       next_frame_is_newly_committed_frame_(false),
       inside_draw_(false),
       input_throttled_until_commit_(false),
       task_runner_provider_(task_runner_provider),
       smoothness_priority_expiration_notifier_(
           task_runner_provider->ImplThreadTaskRunner(),
           base::Bind(&ProxyImpl::RenewTreePriority, base::Unretained(this)),
           base::TimeDelta::FromSecondsD(
               kSmoothnessTakesPriorityExpirationDelay)),
       external_begin_frame_source_(std::move(external_begin_frame_source)),
       rendering_stats_instrumentation_(
           layer_tree_host->rendering_stats_instrumentation()),
       channel_impl_(channel_impl) {
   TRACE_EVENT0("cc", "ProxyImpl::ProxyImpl");
   DCHECK(IsImplThread());
   DCHECK(IsMainThreadBlocked());
 
   layer_tree_host_impl_ = layer_tree_host->CreateLayerTreeHostImpl(this);
 
   SchedulerSettings scheduler_settings(
       layer_tree_host->settings().ToSchedulerSettings());
 
-  scoped_ptr<CompositorTimingHistory> compositor_timing_history(
+  std::unique_ptr<CompositorTimingHistory> compositor_timing_history(
       new CompositorTimingHistory(
           scheduler_settings.using_synchronous_renderer_compositor,
           CompositorTimingHistory::RENDERER_UMA,
           rendering_stats_instrumentation_));
 
   BeginFrameSource* frame_source = external_begin_frame_source_.get();
   if (!scheduler_settings.throttle_frame_production) {
     // Unthrottled source takes precedence over external sources.
     unthrottled_begin_frame_source_.reset(new BackToBackBeginFrameSource(
         task_runner_provider_->ImplThreadTaskRunner()));
@@ skipping 281 matching lines @@
 void ProxyImpl::SetVideoNeedsBeginFrames(bool needs_begin_frames) {
   TRACE_EVENT1("cc", "ProxyImpl::SetVideoNeedsBeginFrames",
                "needs_begin_frames", needs_begin_frames);
   DCHECK(IsImplThread());
   // In tests the layer tree is destroyed after the scheduler is.
   if (scheduler_)
     scheduler_->SetVideoNeedsBeginFrames(needs_begin_frames);
 }
 
 void ProxyImpl::PostAnimationEventsToMainThreadOnImplThread(
-    scoped_ptr<AnimationEvents> events) {
+    std::unique_ptr<AnimationEvents> events) {
   TRACE_EVENT0("cc", "ProxyImpl::PostAnimationEventsToMainThreadOnImplThread");
   DCHECK(IsImplThread());
   channel_impl_->SetAnimationEvents(std::move(events));
 }
 
 bool ProxyImpl::IsInsideDraw() {
   return inside_draw_;
 }
 
 void ProxyImpl::RenewTreePriority() {
@@ skipping 77 matching lines @@
   DCHECK(IsImplThread());
   channel_impl_->DidCompletePageScaleAnimation();
 }
 
 void ProxyImpl::OnDrawForOutputSurface(bool resourceless_software_draw) {
   DCHECK(IsImplThread());
   scheduler_->OnDrawForOutputSurface(resourceless_software_draw);
 }
 
 void ProxyImpl::PostFrameTimingEventsOnImplThread(
-    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(IsImplThread());
   channel_impl_->PostFrameTimingEventsOnMain(std::move(composite_events),
                                              std::move(main_frame_events));
 }
 
 void ProxyImpl::WillBeginImplFrame(const BeginFrameArgs& args) {
   DCHECK(IsImplThread());
   layer_tree_host_impl_->WillBeginImplFrame(args);
   if (last_processed_begin_main_frame_args_.IsValid()) {
     // Last processed begin main frame args records the frame args that we sent
     // to the main thread for the last frame that we've processed. If that is
     // set, that means the current frame is one past the frame in which we've
     // finished the processing.
     layer_tree_host_impl_->RecordMainFrameTiming(
         last_processed_begin_main_frame_args_, args);
     last_processed_begin_main_frame_args_ = BeginFrameArgs();
   }
 }
 
 void ProxyImpl::DidFinishImplFrame() {
   DCHECK(IsImplThread());
   layer_tree_host_impl_->DidFinishImplFrame();
 }
 
 void ProxyImpl::ScheduledActionSendBeginMainFrame(const BeginFrameArgs& args) {
   DCHECK(IsImplThread());
   unsigned int begin_frame_id = nextBeginFrameId++;
   benchmark_instrumentation::ScopedBeginFrameTask begin_frame_task(
       benchmark_instrumentation::kSendBeginFrame, begin_frame_id);
-  scoped_ptr<BeginMainFrameAndCommitState> begin_main_frame_state(
+  std::unique_ptr<BeginMainFrameAndCommitState> begin_main_frame_state(
       new BeginMainFrameAndCommitState);
   begin_main_frame_state->begin_frame_id = begin_frame_id;
   begin_main_frame_state->begin_frame_args = args;
   begin_main_frame_state->scroll_info =
       layer_tree_host_impl_->ProcessScrollDeltas();
   begin_main_frame_state->memory_allocation_limit_bytes =
       layer_tree_host_impl_->memory_allocation_limit_bytes();
   begin_main_frame_state->evicted_ui_resources =
       layer_tree_host_impl_->EvictedUIResourcesExist();
   // TODO(vmpstr): This needs to be fixed if
@@ skipping 162 matching lines @@
 bool ProxyImpl::IsMainThreadBlocked() const {
   return task_runner_provider_->IsMainThreadBlocked();
 }
 
 ProxyImpl::BlockedMainCommitOnly& ProxyImpl::blocked_main_commit() {
   DCHECK(IsMainThreadBlocked() && commit_completion_event_);
   return main_thread_blocked_commit_vars_unsafe_;
 }
 
 }  // namespace cc