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

cc/test/layer_tree_test.cc

 // Copyright 2011 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/test/layer_tree_test.h"
 
 #include "base/command_line.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/timing_function.h"
 #include "cc/base/switches.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/layer.h"
@@ skipping 64 matching lines @@
   outer_viewport_scroll_layer->SetBounds(scroll_bounds);
   outer_viewport_scroll_layer->SetIsDrawable(true);
   CreateVirtualViewportLayers(root_layer, outer_viewport_scroll_layer,
                               inner_bounds, outer_bounds, host);
 }
 
 // Creates a SingleThreadProxy that notifies the supplied |test_hooks| of
 // various actions.
 class SingleThreadProxyForTest : public SingleThreadProxy {
  public:
-  static scoped_ptr<Proxy> Create(TestHooks* test_hooks,
-                                  LayerTreeHost* host,
-                                  LayerTreeHostSingleThreadClient* client,
-                                  TaskRunnerProvider* task_runner_provider) {
-    return make_scoped_ptr(new SingleThreadProxyForTest(
+  static std::unique_ptr<Proxy> Create(
+      TestHooks* test_hooks,
+      LayerTreeHost* host,
+      LayerTreeHostSingleThreadClient* client,
+      TaskRunnerProvider* task_runner_provider) {
+    return base::WrapUnique(new SingleThreadProxyForTest(
         test_hooks, host, client, task_runner_provider));
   }
 
   ~SingleThreadProxyForTest() override {}
 
  private:
   SingleThreadProxyForTest(TestHooks* test_hooks,
                            LayerTreeHost* host,
                            LayerTreeHostSingleThreadClient* client,
                            TaskRunnerProvider* task_runner_provider)
@@ skipping 37 matching lines @@
     SingleThreadProxy::SendBeginMainFrameNotExpectedSoon();
     test_hooks_->SendBeginMainFrameNotExpectedSoon();
   }
 
   TestHooks* test_hooks_;
 };
 
 // Adapts LayerTreeHostImpl for test. Runs real code, then invokes test hooks.
 class LayerTreeHostImplForTesting : public LayerTreeHostImpl {
  public:
-  static scoped_ptr<LayerTreeHostImplForTesting> Create(
+  static std::unique_ptr<LayerTreeHostImplForTesting> Create(
       TestHooks* test_hooks,
       const LayerTreeSettings& settings,
       LayerTreeHostImplClient* host_impl_client,
       TaskRunnerProvider* task_runner_provider,
       SharedBitmapManager* shared_bitmap_manager,
       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
       TaskGraphRunner* task_graph_runner,
       RenderingStatsInstrumentation* stats_instrumentation) {
-    return make_scoped_ptr(new LayerTreeHostImplForTesting(
+    return base::WrapUnique(new LayerTreeHostImplForTesting(
         test_hooks, settings, host_impl_client, task_runner_provider,
         shared_bitmap_manager, gpu_memory_buffer_manager, task_graph_runner,
         stats_instrumentation));
   }
 
  protected:
   LayerTreeHostImplForTesting(
       TestHooks* test_hooks,
       const LayerTreeSettings& settings,
       LayerTreeHostImplClient* host_impl_client,
       TaskRunnerProvider* task_runner_provider,
       SharedBitmapManager* shared_bitmap_manager,
       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
       TaskGraphRunner* task_graph_runner,
       RenderingStatsInstrumentation* stats_instrumentation)
       : LayerTreeHostImpl(settings,
                           host_impl_client,
                           task_runner_provider,
                           stats_instrumentation,
                           shared_bitmap_manager,
                           gpu_memory_buffer_manager,
                           task_graph_runner,
                           0),
         test_hooks_(test_hooks),
         block_notify_ready_to_activate_for_testing_(false),
         notify_ready_to_activate_was_blocked_(false) {}
 
   void CreateResourceAndTileTaskWorkerPool(
-      scoped_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
-      scoped_ptr<ResourcePool>* resource_pool) override {
+      std::unique_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
+      std::unique_ptr<ResourcePool>* resource_pool) override {
     test_hooks_->CreateResourceAndTileTaskWorkerPool(
         this, tile_task_worker_pool, resource_pool);
   }
 
   void WillBeginImplFrame(const BeginFrameArgs& args) override {
     LayerTreeHostImpl::WillBeginImplFrame(args);
     test_hooks_->WillBeginImplFrameOnThread(this, args);
   }
 
   void DidFinishImplFrame() override {
@@ skipping 123 matching lines @@
  private:
   TestHooks* test_hooks_;
   bool block_notify_ready_to_activate_for_testing_;
   bool notify_ready_to_activate_was_blocked_;
 };
 
 // Implementation of LayerTreeHost callback interface.
 class LayerTreeHostClientForTesting : public LayerTreeHostClient,
                                       public LayerTreeHostSingleThreadClient {
  public:
-  static scoped_ptr<LayerTreeHostClientForTesting> Create(
+  static std::unique_ptr<LayerTreeHostClientForTesting> Create(
       TestHooks* test_hooks) {
-    return make_scoped_ptr(new LayerTreeHostClientForTesting(test_hooks));
+    return base::WrapUnique(new LayerTreeHostClientForTesting(test_hooks));
   }
   ~LayerTreeHostClientForTesting() override {}
 
   void WillBeginMainFrame() override { test_hooks_->WillBeginMainFrame(); }
 
   void DidBeginMainFrame() override { test_hooks_->DidBeginMainFrame(); }
 
   void BeginMainFrame(const BeginFrameArgs& args) override {
     test_hooks_->BeginMainFrame(args);
   }
@@ skipping 41 matching lines @@
     test_hooks_->DidCompleteSwapBuffers();
   }
 
   void DidPostSwapBuffers() override {}
   void DidAbortSwapBuffers() override {}
   void RequestScheduleComposite() override { test_hooks_->ScheduleComposite(); }
   void DidCompletePageScaleAnimation() override {}
   void BeginMainFrameNotExpectedSoon() override {}
 
   void RecordFrameTimingEvents(
-      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)
       override {}
 
  private:
   explicit LayerTreeHostClientForTesting(TestHooks* test_hooks)
       : test_hooks_(test_hooks) {}
 
   TestHooks* test_hooks_;
 };
 
 // Adapts LayerTreeHost for test. Injects LayerTreeHostImplForTesting.
 class LayerTreeHostForTesting : public LayerTreeHost {
  public:
-  static scoped_ptr<LayerTreeHostForTesting> Create(
+  static std::unique_ptr<LayerTreeHostForTesting> Create(
       TestHooks* test_hooks,
       CompositorMode mode,
       LayerTreeHostClientForTesting* client,
       RemoteProtoChannel* remote_proto_channel,
       SharedBitmapManager* shared_bitmap_manager,
       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
       TaskGraphRunner* task_graph_runner,
       const LayerTreeSettings& settings,
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
-      scoped_ptr<BeginFrameSource> external_begin_frame_source) {
+      std::unique_ptr<BeginFrameSource> external_begin_frame_source) {
     LayerTreeHost::InitParams params;
     params.client = client;
     params.shared_bitmap_manager = shared_bitmap_manager;
     params.gpu_memory_buffer_manager = gpu_memory_buffer_manager;
     params.task_graph_runner = task_graph_runner;
     params.settings = &settings;
-    scoped_ptr<LayerTreeHostForTesting> layer_tree_host(
+    std::unique_ptr<LayerTreeHostForTesting> layer_tree_host(
         new LayerTreeHostForTesting(test_hooks, &params, mode));
-    scoped_ptr<TaskRunnerProvider> task_runner_provider =
+    std::unique_ptr<TaskRunnerProvider> task_runner_provider =
         TaskRunnerProvider::Create(main_task_runner, impl_task_runner);
-    scoped_ptr<Proxy> proxy;
+    std::unique_ptr<Proxy> proxy;
     switch (mode) {
       case CompositorMode::SINGLE_THREADED:
         proxy = SingleThreadProxyForTest::Create(test_hooks,
                                                  layer_tree_host.get(), client,
                                                  task_runner_provider.get());
         break;
       case CompositorMode::THREADED:
         DCHECK(impl_task_runner.get());
         proxy = ProxyMainForTest::CreateThreaded(
             test_hooks, layer_tree_host.get(), task_runner_provider.get());
@@ skipping 15 matching lines @@
           layer_tree_host->SetOutputSurfaceLostForTesting(false);
         }
         break;
     }
     layer_tree_host->InitializeForTesting(
         std::move(task_runner_provider), std::move(proxy),
         std::move(external_begin_frame_source));
     return layer_tree_host;
   }
 
-  scoped_ptr<LayerTreeHostImpl> CreateLayerTreeHostImpl(
+  std::unique_ptr<LayerTreeHostImpl> CreateLayerTreeHostImpl(
       LayerTreeHostImplClient* host_impl_client) override {
     return LayerTreeHostImplForTesting::Create(
         test_hooks_, settings(), host_impl_client, task_runner_provider(),
         shared_bitmap_manager(), gpu_memory_buffer_manager(),
         task_graph_runner(), rendering_stats_instrumentation());
   }
 
   void SetNeedsCommit() override {
     if (!test_started_)
       return;
@@ skipping 170 matching lines @@
 }
 
 void LayerTreeTest::PostNextCommitWaitsForActivationToMainThread() {
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LayerTreeTest::DispatchNextCommitWaitsForActivation,
                  main_thread_weak_ptr_));
 }
 
 void LayerTreeTest::SetOutputSurfaceOnLayerTreeHost(
-    scoped_ptr<OutputSurface> output_surface) {
+    std::unique_ptr<OutputSurface> output_surface) {
   if (IsRemoteTest()) {
     DCHECK(remote_client_layer_tree_host_);
     remote_client_layer_tree_host_->SetOutputSurface(std::move(output_surface));
   } else {
     layer_tree_host_->SetOutputSurface(std::move(output_surface));
   }
 }
 
-scoped_ptr<OutputSurface> LayerTreeTest::ReleaseOutputSurfaceOnLayerTreeHost() {
+std::unique_ptr<OutputSurface>
+LayerTreeTest::ReleaseOutputSurfaceOnLayerTreeHost() {
   if (IsRemoteTest()) {
     DCHECK(remote_client_layer_tree_host_);
     return remote_client_layer_tree_host_->ReleaseOutputSurface();
   }
   return layer_tree_host_->ReleaseOutputSurface();
 }
 
 void LayerTreeTest::SetVisibleOnLayerTreeHost(bool visible) {
   layer_tree_host_->SetVisible(visible);
 
   if (IsRemoteTest()) {
     DCHECK(remote_client_layer_tree_host_);
     remote_client_layer_tree_host_->SetVisible(visible);
   }
 }
 
 void LayerTreeTest::WillBeginTest() {
   SetVisibleOnLayerTreeHost(true);
 }
 
 void LayerTreeTest::DoBeginTest() {
   client_ = LayerTreeHostClientForTesting::Create(this);
 
-  scoped_ptr<FakeExternalBeginFrameSource> external_begin_frame_source;
+  std::unique_ptr<FakeExternalBeginFrameSource> external_begin_frame_source;
   if (settings_.use_external_begin_frame_source) {
     DCHECK(!IsRemoteTest());
     external_begin_frame_source.reset(new FakeExternalBeginFrameSource(
         settings_.renderer_settings.refresh_rate));
     external_begin_frame_source_ = external_begin_frame_source.get();
   }
 
   DCHECK(!impl_thread_ || impl_thread_->task_runner().get());
 
   if (IsRemoteTest()) {
@@ skipping 189 matching lines @@
     FAIL() << "Test timed out";
     return;
   }
   AfterTest();
 }
 
 void LayerTreeTest::RequestNewOutputSurface() {
   SetOutputSurfaceOnLayerTreeHost(CreateOutputSurface());
 }
 
-scoped_ptr<OutputSurface> LayerTreeTest::CreateOutputSurface() {
-  scoped_ptr<FakeOutputSurface> output_surface = CreateFakeOutputSurface();
+std::unique_ptr<OutputSurface> LayerTreeTest::CreateOutputSurface() {
+  std::unique_ptr<FakeOutputSurface> output_surface = CreateFakeOutputSurface();
   DCHECK_EQ(delegating_renderer_,
             output_surface->capabilities().delegated_rendering);
   output_surface_ = output_surface.get();
 
   if (settings_.use_external_begin_frame_source &&
       settings_.wait_for_beginframe_interval) {
     DCHECK(external_begin_frame_source_);
   }
   return std::move(output_surface);
 }
 
-scoped_ptr<FakeOutputSurface> LayerTreeTest::CreateFakeOutputSurface() {
+std::unique_ptr<FakeOutputSurface> LayerTreeTest::CreateFakeOutputSurface() {
   if (delegating_renderer_)
     return FakeOutputSurface::CreateDelegating3d();
   else
     return FakeOutputSurface::Create3d();
 }
 
 TestWebGraphicsContext3D* LayerTreeTest::TestContext() {
   return static_cast<TestContextProvider*>(output_surface_->context_provider())
       ->TestContext3d();
 }
@@ skipping 104 matching lines @@
 
 RemoteChannelImplForTest* LayerTreeTest::GetRemoteChannelImplForTest() const {
   DCHECK(IsRemoteTest());
   DCHECK(remote_client_layer_tree_host_);
 
   return static_cast<RemoteChannelImplForTest*>(
       remote_client_layer_tree_host_->proxy());
 }
 
 }  // namespace cc