Convert //content/renderer from scoped_ptr to std::unique_ptr

content/renderer/gpu/render_widget_compositor_unittest.cc

 // Copyright 2014 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 "content/renderer/gpu/render_widget_compositor.h"
 
 #include <utility>
 
 #include "base/location.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/test/failure_output_surface.h"
 #include "cc/trees/layer_tree_host.h"
 #include "components/scheduler/renderer/renderer_scheduler.h"
 #include "content/public/test/mock_render_thread.h"
 #include "content/renderer/render_widget.h"
 #include "content/test/fake_compositor_dependencies.h"
 #include "content/test/fake_renderer_scheduler.h"
@@ skipping 43 matching lines @@
         render_widget_(new TestRenderWidget(compositor_deps_.get())),
         render_widget_compositor_(RenderWidgetCompositor::Create(
             render_widget_.get(),
             1.f /* initial_device_scale_factor */,
             compositor_deps_.get())) {}
   ~RenderWidgetCompositorTest() override {}
 
  protected:
   base::MessageLoop loop_;
   MockRenderThread render_thread_;
-  scoped_ptr<FakeCompositorDependencies> compositor_deps_;
+  std::unique_ptr<FakeCompositorDependencies> compositor_deps_;
   scoped_refptr<TestRenderWidget> render_widget_;
-  scoped_ptr<RenderWidgetCompositor> render_widget_compositor_;
+  std::unique_ptr<RenderWidgetCompositor> render_widget_compositor_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetCompositorTest);
 };
 
 TEST_F(RenderWidgetCompositorTest, BeginMainFrame) {
   base::TimeTicks frame_time(base::TimeTicks() +
                              base::TimeDelta::FromSeconds(1));
   base::TimeTicks deadline(base::TimeTicks() + base::TimeDelta::FromSeconds(2));
   base::TimeDelta interval(base::TimeDelta::FromSeconds(3));
   cc::BeginFrameArgs args(
       cc::BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, frame_time, deadline,
                                  interval, cc::BeginFrameArgs::NORMAL));
 
   EXPECT_CALL(render_widget_->mock_webwidget_, beginFrame(1));
 
   render_widget_compositor_->BeginMainFrame(args);
 }
 
 class RenderWidgetCompositorOutputSurface;
 
 class RenderWidgetOutputSurface : public TestRenderWidget {
  public:
   explicit RenderWidgetOutputSurface(CompositorDependencies* compositor_deps)
       : TestRenderWidget(compositor_deps), compositor_(NULL) {}
   void SetCompositor(RenderWidgetCompositorOutputSurface* compositor);
 
-  scoped_ptr<cc::OutputSurface> CreateOutputSurface(bool fallback) override;
+  std::unique_ptr<cc::OutputSurface> CreateOutputSurface(
+      bool fallback) override;
 
  protected:
   ~RenderWidgetOutputSurface() override {}
 
  private:
   RenderWidgetCompositorOutputSurface* compositor_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetOutputSurface);
 };
 
@@ skipping 15 matching lines @@
         num_requests_(0),
         num_requests_since_last_success_(0),
         num_successes_(0),
         num_fallback_successes_(0),
         num_failures_(0),
         last_create_was_fallback_(false),
         use_null_output_surface_(true) {}
 
   using RenderWidgetCompositor::Initialize;
 
-  scoped_ptr<cc::OutputSurface> CreateOutputSurface(bool fallback) {
+  std::unique_ptr<cc::OutputSurface> CreateOutputSurface(bool fallback) {
     EXPECT_EQ(num_requests_since_last_success_ >
                   OUTPUT_SURFACE_RETRIES_BEFORE_FALLBACK,
               fallback);
     last_create_was_fallback_ = fallback;
     bool success = num_failures_ >= num_failures_before_success_;
     if (success) {
-      scoped_ptr<cc::TestWebGraphicsContext3D> context =
+      std::unique_ptr<cc::TestWebGraphicsContext3D> context =
           cc::TestWebGraphicsContext3D::Create();
       // Image support required for synchronous compositing.
       context->set_support_image(true);
       // Create delegating surface so that max_pending_frames = 1.
       return cc::FakeOutputSurface::CreateDelegating3d(std::move(context));
     }
     return use_null_output_surface_
                ? nullptr
-               : make_scoped_ptr(new cc::FailureOutputSurface(true));
+               : base::WrapUnique(new cc::FailureOutputSurface(true));
   }
 
   // Force a new output surface to be created.
   void SynchronousComposite() {
    layer_tree_host()->DidLoseOutputSurface();
 
    base::TimeTicks some_time;
    layer_tree_host()->Composite(some_time);
   }
 
@@ skipping 94 matching lines @@
         FROM_HERE,
         base::Bind(&RenderWidgetCompositorOutputSurface::SynchronousComposite,
                    base::Unretained(render_widget_compositor_.get())));
     base::MessageLoop::current()->Run();
     render_widget_compositor_->AfterTest();
   }
 
  protected:
   base::MessageLoop ye_olde_message_loope_;
   MockRenderThread render_thread_;
-  scoped_ptr<FakeCompositorDependencies> compositor_deps_;
+  std::unique_ptr<FakeCompositorDependencies> compositor_deps_;
   scoped_refptr<RenderWidgetOutputSurface> render_widget_;
-  scoped_ptr<RenderWidgetCompositorOutputSurface> render_widget_compositor_;
+  std::unique_ptr<RenderWidgetCompositorOutputSurface>
+      render_widget_compositor_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetCompositorOutputSurfaceTest);
 };
 
-scoped_ptr<cc::OutputSurface> RenderWidgetOutputSurface::CreateOutputSurface(
-    bool fallback) {
+std::unique_ptr<cc::OutputSurface>
+RenderWidgetOutputSurface::CreateOutputSurface(bool fallback) {
   return compositor_->CreateOutputSurface(fallback);
 }
 
 void RenderWidgetOutputSurface::SetCompositor(
     RenderWidgetCompositorOutputSurface* compositor) {
   compositor_ = compositor;
 }
 
 TEST_F(RenderWidgetCompositorOutputSurfaceTest, SucceedOnce) {
   RunTest(false, 0, 1, 0);
@@ skipping 28 matching lines @@
 }
 
 TEST_F(RenderWidgetCompositorOutputSurfaceTest, FallbackSuccessNormalSuccess) {
   // The first success is a fallback, but the next should not be a fallback.
   RunTest(false, RenderWidgetCompositor::OUTPUT_SURFACE_RETRIES_BEFORE_FALLBACK,
           1, 1);
 }
 
 }  // namespace
 }  // namespace content