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

cc/trees/layer_tree_host_unittest_copyrequest.cc

 // Copyright 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 <stddef.h>
 
+#include "base/memory/ptr_util.h"
 #include "cc/layers/layer_iterator.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_picture_layer.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "gpu/GLES2/gl2extchromium.h"
 
@@ skipping 87 matching lines @@
         EXPECT_EQ(gfx::Size(10, 10).ToString(), callbacks_[1].ToString());
         // The |root| was copied to a bitmap and passed back also in Case 2.
         EXPECT_EQ(gfx::Size(20, 20).ToString(), callbacks_[2].ToString());
         // The |grand_child| was copied to a bitmap and passed back in Case 2.
         EXPECT_EQ(gfx::Size(5, 5).ToString(), callbacks_[3].ToString());
         EndTest();
         break;
     }
   }
 
-  void CopyOutputCallback(size_t id, scoped_ptr<CopyOutputResult> result) {
+  void CopyOutputCallback(size_t id, std::unique_ptr<CopyOutputResult> result) {
     EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
     EXPECT_TRUE(result->HasBitmap());
-    scoped_ptr<SkBitmap> bitmap = result->TakeBitmap();
+    std::unique_ptr<SkBitmap> bitmap = result->TakeBitmap();
     EXPECT_EQ(result->size().ToString(),
               gfx::Size(bitmap->width(), bitmap->height()).ToString());
     callbacks_[id] = result->size();
   }
 
   void AfterTest() override { EXPECT_EQ(4u, callbacks_.size()); }
 
-  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
+  std::unique_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
     if (!use_gl_renderer_) {
       return FakeOutputSurface::CreateSoftware(
-          make_scoped_ptr(new SoftwareOutputDevice));
+          base::WrapUnique(new SoftwareOutputDevice));
     }
-    scoped_ptr<FakeOutputSurface> output_surface =
+    std::unique_ptr<FakeOutputSurface> output_surface =
         FakeOutputSurface::Create3d();
     TestContextSupport* context_support = static_cast<TestContextSupport*>(
         output_surface->context_provider()->ContextSupport());
     context_support->set_out_of_order_callbacks(out_of_order_callbacks_);
     return output_surface;
   }
 
   bool use_gl_renderer_;
   bool out_of_order_callbacks_ = false;
   std::map<size_t, gfx::Size> callbacks_;
@@ skipping 75 matching lines @@
       case 2:
         // This commit is triggered by the copy request.
         break;
       case 3:
         // This commit is triggered by the completion of the copy request.
         EndTest();
         break;
     }
   }
 
-  static void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
+  static void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {
     EXPECT_FALSE(result->IsEmpty());
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root_;
   scoped_refptr<FakePictureLayer> layer_;
 };
 
@@ skipping 69 matching lines @@
         layer_tree_host()->SetNeedsCommit();
         break;
       case 5:
         // We should get another callback with a NULL bitmap.
         EXPECT_EQ(2, callback_count_);
         EndTest();
         break;
     }
   }
 
-  void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
+  void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {
     EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
     EXPECT_TRUE(result->IsEmpty());
     ++callback_count_;
   }
 
   void AfterTest() override {}
 
   int callback_count_;
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root_;
@@ skipping 36 matching lines @@
             base::Unretained(this))));
   }
 
   void BeginTest() override {
     callback_count_ = 0;
     PostSetNeedsCommitToMainThread();
 
     AddCopyRequest(copy_layer_.get());
   }
 
-  void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
+  void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {
     ++callback_count_;
     EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
     EXPECT_EQ(copy_layer_->bounds().ToString(), result->size().ToString())
         << callback_count_;
     switch (callback_count_) {
       case 1:
         // Hide the copy request layer.
         grand_parent_layer_->SetHideLayerAndSubtree(false);
         parent_layer_->SetHideLayerAndSubtree(false);
         copy_layer_->SetHideLayerAndSubtree(true);
@@ skipping 77 matching lines @@
     did_draw_ = false;
     PostSetNeedsCommitToMainThread();
 
     copy_layer_->RequestCopyOfOutput(
         CopyOutputRequest::CreateBitmapRequest(base::Bind(
             &LayerTreeHostTestHiddenSurfaceNotAllocatedForSubtreeCopyRequest::
                  CopyOutputCallback,
             base::Unretained(this))));
   }
 
-  void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
+  void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {
     EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
     EXPECT_EQ(copy_layer_->bounds().ToString(), result->size().ToString());
     EndTest();
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     Renderer* renderer = host_impl->renderer();
 
     LayerImpl* root = host_impl->active_tree()->root_layer();
     LayerImpl* grand_parent = root->children()[0];
@@ skipping 56 matching lines @@
   }
 
   void BeginTest() override {
     PostSetNeedsCommitToMainThread();
 
     copy_layer_->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
         base::Bind(&LayerTreeHostCopyRequestTestClippedOut::CopyOutputCallback,
                    base::Unretained(this))));
   }
 
-  void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
+  void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {
     // We should still get the content even if the copy requested layer was
     // completely clipped away.
     EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
     EXPECT_EQ(gfx::Size(10, 10).ToString(), result->size().ToString());
     EndTest();
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient client_;
@@ skipping 25 matching lines @@
     copy_layer_->AddChild(child_layer_);
 
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostCopyRequestTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   void BeginTest() override {
     PostSetNeedsCommitToMainThread();
 
-    scoped_ptr<CopyOutputRequest> request =
+    std::unique_ptr<CopyOutputRequest> request =
         CopyOutputRequest::CreateBitmapRequest(base::Bind(
             &LayerTreeHostCopyRequestTestScaledLayer::CopyOutputCallback,
             base::Unretained(this)));
     request->set_area(gfx::Rect(5, 5));
     copy_layer_->RequestCopyOfOutput(std::move(request));
   }
 
-  void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
+  void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {
     // The request area is expressed in layer space, but the result's size takes
     // into account the transform from layer space to surface space.
     EXPECT_EQ(gfx::Size(10, 10), result->size());
     EndTest();
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_;
@@ skipping 48 matching lines @@
 
   void DidCommit() override {
     if (layer_tree_host()->source_frame_number() == 1) {
       // Allow drawing.
       layer_tree_host()->SetViewportSize(gfx::Size(root_->bounds()));
 
       AddCopyRequest(copy_layer_.get());
     }
   }
 
-  void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
+  void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {
     EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
 
     // The first frame can't be drawn.
     switch (callback_count_) {
       case 0:
         EXPECT_TRUE(result->IsEmpty());
         EXPECT_EQ(gfx::Size(), result->size());
         break;
       case 1:
         EXPECT_FALSE(result->IsEmpty());
@@ skipping 16 matching lines @@
   scoped_refptr<FakePictureLayer> root_;
   scoped_refptr<FakePictureLayer> copy_layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     LayerTreeHostTestAsyncTwoReadbacksWithoutDraw);
 
 class LayerTreeHostCopyRequestTestLostOutputSurface
     : public LayerTreeHostCopyRequestTest {
  protected:
-  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
+  std::unique_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
     if (!first_context_provider_) {
       first_context_provider_ = TestContextProvider::Create();
       return FakeOutputSurface::Create3d(first_context_provider_);
     }
 
     EXPECT_FALSE(second_context_provider_);
     second_context_provider_ = TestContextProvider::Create();
     return FakeOutputSurface::Create3d(second_context_provider_);
   }
 
   void SetupTree() override {
     root_ = FakePictureLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
 
     copy_layer_ = FakePictureLayer::Create(&client_);
     copy_layer_->SetBounds(gfx::Size(10, 10));
     root_->AddChild(copy_layer_);
 
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostCopyRequestTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  void ReceiveCopyRequestOutputAndCommit(scoped_ptr<CopyOutputResult> result) {
+  void ReceiveCopyRequestOutputAndCommit(
+      std::unique_ptr<CopyOutputResult> result) {
     EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
     EXPECT_EQ(gfx::Size(10, 10).ToString(), result->size().ToString());
     EXPECT_TRUE(result->HasTexture());
 
     // Save the result for later.
     EXPECT_FALSE(result_);
     result_ = std::move(result);
 
     // Post a commit to lose the output surface.
     layer_tree_host()->SetNeedsCommit();
@@ skipping 78 matching lines @@
 
   void AfterTest() override {}
 
   scoped_refptr<TestContextProvider> first_context_provider_;
   scoped_refptr<TestContextProvider> second_context_provider_;
   size_t num_textures_without_readback_ = 0;
   size_t num_textures_after_loss_ = 0;
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root_;
   scoped_refptr<FakePictureLayer> copy_layer_;
-  scoped_ptr<CopyOutputResult> result_;
+  std::unique_ptr<CopyOutputResult> result_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     LayerTreeHostCopyRequestTestLostOutputSurface);
 
 class LayerTreeHostCopyRequestTestCountTextures
     : public LayerTreeHostCopyRequestTest {
  protected:
-  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
+  std::unique_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
     context_provider_ = TestContextProvider::Create();
     return FakeOutputSurface::Create3d(context_provider_);
   }
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
 
     root_ = FakePictureLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
 
@@ skipping 62 matching lines @@
     : public LayerTreeHostCopyRequestTestCountTextures {
  protected:
   void RequestCopy(Layer* layer) override {
     // Request a normal texture copy. This should create a new texture.
     copy_layer_->RequestCopyOfOutput(
         CopyOutputRequest::CreateRequest(base::Bind(
             &LayerTreeHostCopyRequestTestCreatesTexture::CopyOutputCallback,
             base::Unretained(this))));
   }
 
-  void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
+  void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {
     EXPECT_FALSE(result->IsEmpty());
     EXPECT_TRUE(result->HasTexture());
 
     TextureMailbox mailbox;
-    scoped_ptr<SingleReleaseCallback> release;
+    std::unique_ptr<SingleReleaseCallback> release;
     result->TakeTexture(&mailbox, &release);
     EXPECT_TRUE(release);
 
     release->Run(gpu::SyncToken(), false);
   }
 
   void AfterTest() override {
     // No sync point was needed.
     EXPECT_FALSE(waited_sync_token_after_readback_.HasData());
     // Except the copy to have made another texture.
     EXPECT_EQ(num_textures_without_readback_ + 1, num_textures_with_readback_);
   }
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     LayerTreeHostCopyRequestTestCreatesTexture);
 
 class LayerTreeHostCopyRequestTestProvideTexture
     : public LayerTreeHostCopyRequestTestCountTextures {
  protected:
   void BeginTest() override {
     external_context_provider_ = TestContextProvider::Create();
     EXPECT_TRUE(external_context_provider_->BindToCurrentThread());
     LayerTreeHostCopyRequestTestCountTextures::BeginTest();
   }
 
-  void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
+  void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {
     EXPECT_FALSE(result->IsEmpty());
     EXPECT_TRUE(result->HasTexture());
 
     TextureMailbox mailbox;
-    scoped_ptr<SingleReleaseCallback> release;
+    std::unique_ptr<SingleReleaseCallback> release;
     result->TakeTexture(&mailbox, &release);
     EXPECT_FALSE(release);
   }
 
   void RequestCopy(Layer* layer) override {
     // Request a copy to a provided texture. This should not create a new
     // texture.
-    scoped_ptr<CopyOutputRequest> request =
+    std::unique_ptr<CopyOutputRequest> request =
         CopyOutputRequest::CreateRequest(base::Bind(
             &LayerTreeHostCopyRequestTestProvideTexture::CopyOutputCallback,
             base::Unretained(this)));
 
     gpu::gles2::GLES2Interface* gl = external_context_provider_->ContextGL();
     gpu::Mailbox mailbox;
     gl->GenMailboxCHROMIUM(mailbox.name);
 
     const GLuint64 fence_sync = gl->InsertFenceSyncCHROMIUM();
     gl->ShallowFlushCHROMIUM();
@@ skipping 35 matching lines @@
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostCopyRequestTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   void BeginTest() override {
     callback_count_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
-  void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
+  void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {
     EXPECT_TRUE(result->IsEmpty());
     ++callback_count_;
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     MainThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeHostCopyRequestTestDestroyBeforeCopy::DidActivate,
                    base::Unretained(this)));
   }
 
   void DidActivate() {
     switch (layer_tree_host()->source_frame_number()) {
       case 1: {
         EXPECT_EQ(0, callback_count_);
         // Put a copy request on the layer, but then don't allow any
         // drawing to take place.
-        scoped_ptr<CopyOutputRequest> request =
+        std::unique_ptr<CopyOutputRequest> request =
             CopyOutputRequest::CreateRequest(
                 base::Bind(&LayerTreeHostCopyRequestTestDestroyBeforeCopy::
-                                CopyOutputCallback,
+                               CopyOutputCallback,
                            base::Unretained(this)));
         copy_layer_->RequestCopyOfOutput(std::move(request));
 
         layer_tree_host()->SetViewportSize(gfx::Size());
         break;
       }
       case 2:
         EXPECT_EQ(0, callback_count_);
         // Remove the copy layer before we were able to draw.
         copy_layer_->RemoveFromParent();
@@ skipping 36 matching lines @@
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostCopyRequestTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   void BeginTest() override {
     callback_count_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
-  void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
+  void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {
     EXPECT_TRUE(result->IsEmpty());
     ++callback_count_;
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     MainThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeHostCopyRequestTestShutdownBeforeCopy::DidActivate,
                    base::Unretained(this)));
   }
 
   void DidActivate() {
     switch (layer_tree_host()->source_frame_number()) {
       case 1: {
         EXPECT_EQ(0, callback_count_);
         // Put a copy request on the layer, but then don't allow any
         // drawing to take place.
-        scoped_ptr<CopyOutputRequest> request =
+        std::unique_ptr<CopyOutputRequest> request =
             CopyOutputRequest::CreateRequest(
                 base::Bind(&LayerTreeHostCopyRequestTestShutdownBeforeCopy::
-                                CopyOutputCallback,
+                               CopyOutputCallback,
                            base::Unretained(this)));
         copy_layer_->RequestCopyOfOutput(std::move(request));
 
         layer_tree_host()->SetViewportSize(gfx::Size());
         break;
       }
       case 2:
         DestroyLayerTreeHost();
         // End the test after the copy result has had a chance to get back to
         // the main thread.
@@ skipping 102 matching lines @@
             FROM_HERE,
             base::Bind(
                 &LayerTreeHostCopyRequestTestMultipleDrawsHiddenCopyRequest::
                     TryEndTest,
                 base::Unretained(this)));
         break;
     }
     return draw_result;
   }
 
-  void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
+  void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {
     EXPECT_FALSE(TestEnded());
     copy_happened_ = true;
     TryEndTest();
   }
 
   void TryEndTest() {
     if (draw_happened_ && copy_happened_)
       EndTest();
   }
 
   void AfterTest() override {}
 
   scoped_refptr<FakePictureLayer> child_;
   FakeContentLayerClient client_;
   int num_draws_;
   bool copy_happened_;
   bool draw_happened_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     LayerTreeHostCopyRequestTestMultipleDrawsHiddenCopyRequest);
 
 }  // namespace
 }  // namespace cc