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

cc/trees/layer_tree_host_unittest_context.cc

 // Copyright 2012 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/layer_tree_host.h"
-
 #include <stddef.h>
 #include <stdint.h>
 
+#include "base/memory/ptr_util.h"
 #include "cc/layers/heads_up_display_layer.h"
 #include "cc/layers/io_surface_layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/painted_scrollbar_layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/layers/texture_layer.h"
 #include "cc/layers/texture_layer_impl.h"
 #include "cc/layers/video_layer.h"
 #include "cc/layers/video_layer_impl.h"
 #include "cc/output/filter_operations.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/test/failure_output_surface.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/fake_painted_scrollbar_layer.h"
 #include "cc/test/fake_picture_layer.h"
 #include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/fake_resource_provider.h"
 #include "cc/test/fake_scoped_ui_resource.h"
 #include "cc/test/fake_scrollbar.h"
 #include "cc/test/fake_video_frame_provider.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/test/render_pass_test_utils.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_web_graphics_context_3d.h"
+#include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "media/base/media.h"
 
 using media::VideoFrame;
 
 namespace cc {
 namespace {
@@ skipping 22 matching lines @@
     // to make sure we don't set it to null after recreating it there.
     base::AutoLock lock(context3d_lock_);
     // For sanity-checking tests, they should only call this when the
     // context is not lost.
     CHECK(context3d_);
     context3d_->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
                                     GL_INNOCENT_CONTEXT_RESET_ARB);
     context3d_ = NULL;
   }
 
-  virtual scoped_ptr<TestWebGraphicsContext3D> CreateContext3d() {
+  virtual std::unique_ptr<TestWebGraphicsContext3D> CreateContext3d() {
     return TestWebGraphicsContext3D::Create();
   }
 
-  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
+  std::unique_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
     if (times_to_fail_create_) {
       --times_to_fail_create_;
       ExpectCreateToFail();
-      return make_scoped_ptr(new FailureOutputSurface(delegating_renderer()));
+      return base::WrapUnique(new FailureOutputSurface(delegating_renderer()));
     }
 
-    scoped_ptr<TestWebGraphicsContext3D> context3d = CreateContext3d();
+    std::unique_ptr<TestWebGraphicsContext3D> context3d = CreateContext3d();
     base::AutoLock lock(context3d_lock_);
     context3d_ = context3d.get();
 
     if (context_should_support_io_surface_) {
       context3d_->set_have_extension_io_surface(true);
       context3d_->set_have_extension_egl_image(true);
     }
 
     if (delegating_renderer())
       return FakeOutputSurface::CreateDelegating3d(std::move(context3d));
@@ skipping 80 matching lines @@
       MainThreadTaskRunner()->PostTask(
           FROM_HERE, base::Bind(&LayerTreeHostContextTestLostContextSucceeds::
                                     CreateAndSetOutputSurface,
                                 base::Unretained(this)));
     } else {
       CreateAndSetOutputSurface();
     }
   }
 
   void CreateAndSetOutputSurface() {
-    scoped_ptr<OutputSurface> surface(
+    std::unique_ptr<OutputSurface> surface(
         LayerTreeHostContextTest::CreateOutputSurface());
     CHECK(surface);
     layer_tree_host()->SetOutputSurface(std::move(surface));
   }
 
   void DidInitializeOutputSurface() override {
     if (first_initialized_)
       ++num_losses_;
     else
       first_initialized_ = true;
@@ skipping 158 matching lines @@
   void WillBeginTest() override {
     // Override to not become visible.
     DCHECK(!layer_tree_host()->visible());
   }
 
   void BeginTest() override {
     PostSetNeedsCommitToMainThread();
     EndTest();
   }
 
-  scoped_ptr<OutputSurface> CreateOutputSurface() override {
+  std::unique_ptr<OutputSurface> CreateOutputSurface() override {
     EXPECT_TRUE(false);
     return nullptr;
   }
 
   void DidInitializeOutputSurface() override { EXPECT_TRUE(false); }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
@@ skipping 13 matching lines @@
       : LayerTreeHostContextTest(), setos_counter_(0) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void RequestNewOutputSurface() override {
     if (layer_tree_host()->visible())
       CreateAndSetOutputSurface();
   }
 
   void CreateAndSetOutputSurface() {
-    scoped_ptr<OutputSurface> surface =
+    std::unique_ptr<OutputSurface> surface =
         LayerTreeHostContextTest::CreateOutputSurface();
     CHECK(surface);
     setos_counter_++;
     layer_tree_host()->SetOutputSurface(std::move(surface));
   }
 
   void HideAndReleaseOutputSurface() {
     EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
     layer_tree_host()->SetVisible(false);
-    scoped_ptr<OutputSurface> surface =
+    std::unique_ptr<OutputSurface> surface =
         layer_tree_host()->ReleaseOutputSurface();
     CHECK(surface);
     MainThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeHostClientTakeAwayOutputSurface::MakeVisible,
                    base::Unretained(this)));
   }
 
   void DidInitializeOutputSurface() override {
     EXPECT_TRUE(layer_tree_host()->visible());
@@ skipping 33 matching lines @@
   void RequestNewOutputSurface() override {
     EXPECT_GE(1, ++request_count_);
     EndTest();
   }
 
   void BeginTest() override {
     layer_tree_host()->Composite(base::TimeTicks::FromInternalValue(1));
     layer_tree_host()->Composite(base::TimeTicks::FromInternalValue(2));
   }
 
-  scoped_ptr<OutputSurface> CreateOutputSurface() override {
+  std::unique_ptr<OutputSurface> CreateOutputSurface() override {
     EXPECT_TRUE(false);
     return nullptr;
   }
 
   void DidInitializeOutputSurface() override { EXPECT_TRUE(false); }
 
   void AfterTest() override {}
 
   int request_count_;
 };
@@ skipping 18 matching lines @@
   void RequestNewOutputSurface() override {
     num_requests_++;
     // There should be one initial request and then one request from
     // the LayerTreeTest test hooks DidFailToInitializeOutputSurface (which is
     // hard to skip).  This second request is just ignored and is test cruft.
     EXPECT_LE(num_requests_, 2);
     if (num_requests_ > 1)
       return;
     ExpectCreateToFail();
     layer_tree_host()->SetOutputSurface(
-        make_scoped_ptr(new FailureOutputSurface(false)));
+        base::WrapUnique(new FailureOutputSurface(false)));
   }
 
   void BeginTest() override {
     // First composite tries to create a surface.
     layer_tree_host()->Composite(base::TimeTicks::FromInternalValue(1));
     EXPECT_EQ(num_requests_, 2);
     EXPECT_TRUE(has_failed_);
 
     // Second composite should not request or fail.
     layer_tree_host()->Composite(base::TimeTicks::FromInternalValue(2));
@@ skipping 392 matching lines @@
         child_output_surface_.get(), shared_bitmap_manager_.get());
   }
 
   static void EmptyReleaseCallback(const gpu::SyncToken& sync_token,
                                    bool lost) {}
 
   void SetupTree() override {
     gpu::gles2::GLES2Interface* gl =
         child_output_surface_->context_provider()->ContextGL();
 
-    scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
+    std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
 
-    scoped_ptr<RenderPass> pass_for_quad = RenderPass::Create();
+    std::unique_ptr<RenderPass> pass_for_quad = RenderPass::Create();
     pass_for_quad->SetNew(
         // AppendOneOfEveryQuadType() makes a RenderPass quad with this id.
         RenderPassId(2, 1),
         gfx::Rect(0, 0, 10, 10),
         gfx::Rect(0, 0, 10, 10),
         gfx::Transform());
 
-    scoped_ptr<RenderPass> pass = RenderPass::Create();
+    std::unique_ptr<RenderPass> pass = RenderPass::Create();
     pass->SetNew(RenderPassId(1, 1),
                  gfx::Rect(0, 0, 10, 10),
                  gfx::Rect(0, 0, 10, 10),
                  gfx::Transform());
     gpu::SyncToken mailbox_sync_token;
     AddOneOfEveryQuadType(pass.get(), child_resource_provider_.get(),
                           RenderPassId(2, 1), &mailbox_sync_token);
 
     frame_data->render_pass_list.push_back(std::move(pass_for_quad));
     frame_data->render_pass_list.push_back(std::move(pass));
@@ skipping 85 matching lines @@
     io_surface->SetIsDrawable(true);
     io_surface->SetIOSurfaceProperties(1, gfx::Size(10, 10));
     root->AddChild(io_surface);
 
     // Enable the hud.
     LayerTreeDebugState debug_state;
     debug_state.show_property_changed_rects = true;
     layer_tree_host()->SetDebugState(debug_state);
 
     scoped_refptr<PaintedScrollbarLayer> scrollbar =
-        PaintedScrollbarLayer::Create(scoped_ptr<Scrollbar>(new FakeScrollbar),
-                                      layer->id());
+        PaintedScrollbarLayer::Create(
+            std::unique_ptr<Scrollbar>(new FakeScrollbar), layer->id());
     scrollbar->SetBounds(gfx::Size(10, 10));
     scrollbar->SetIsDrawable(true);
     root->AddChild(scrollbar);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostContextTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
@@ skipping 13 matching lines @@
                                    LayerTreeHostImpl::FrameData* frame,
                                    DrawResult draw_result) override {
     if (host_impl->active_tree()->source_frame_number() == 2) {
       // Lose the context during draw on the second commit. This will cause
       // a third commit to recover.
       context3d_->set_times_bind_texture_succeeds(0);
     }
     return draw_result;
   }
 
-  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
+  std::unique_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
     // This will get called twice:
     // First when we create the initial output surface...
     if (layer_tree_host()->source_frame_number() > 0) {
       // ... and then again after we forced the context to be lost.
       lost_context_ = true;
     }
     return LayerTreeHostContextTest::CreateFakeOutputSurface();
   }
 
   void DidCommitAndDrawFrame() override {
     ASSERT_TRUE(layer_tree_host()->hud_layer());
     // End the test once we know the 3nd frame drew.
     if (layer_tree_host()->source_frame_number() < 5) {
       layer_tree_host()->root_layer()->SetNeedsDisplay();
       layer_tree_host()->SetNeedsCommit();
     } else {
       EndTest();
     }
   }
 
   void AfterTest() override { EXPECT_TRUE(lost_context_); }
 
  private:
   FakeContentLayerClient client_;
   bool lost_context_;
 
   FakeOutputSurfaceClient output_surface_client_;
-  scoped_ptr<FakeOutputSurface> child_output_surface_;
-  scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
-  scoped_ptr<ResourceProvider> child_resource_provider_;
+  std::unique_ptr<FakeOutputSurface> child_output_surface_;
+  std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
+  std::unique_ptr<ResourceProvider> child_resource_provider_;
 
   scoped_refptr<VideoFrame> color_video_frame_;
   scoped_refptr<VideoFrame> hw_video_frame_;
   scoped_refptr<VideoFrame> scaled_hw_video_frame_;
 
   FakeVideoFrameProvider color_frame_provider_;
   FakeVideoFrameProvider hw_frame_provider_;
   FakeVideoFrameProvider scaled_hw_frame_provider_;
 };
 
@@ skipping 108 matching lines @@
   void PostLoseContextToImplThread() {
     EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
     ImplThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeHostContextTest::LoseContext,
                    base::Unretained(this)));
   }
 
  protected:
   int time_step_;
-  scoped_ptr<FakeScopedUIResource> ui_resource_;
+  std::unique_ptr<FakeScopedUIResource> ui_resource_;
 
  private:
   void StepCompleteOnMainThreadInternal(int step) {
     EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
     StepCompleteOnMainThread(step);
   }
 };
 
 class UIResourceLostTestSimple : public UIResourceLostTest {
  public:
@@ skipping 368 matching lines @@
   void AfterTest() override {}
 
   bool deferred_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostContextTestLoseAfterSendingBeginMainFrame);
 
 }  // namespace
 }  // namespace cc