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

cc/scheduler/scheduler_unittest.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/scheduler/scheduler.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "cc/test/scheduler_test_common.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 177 matching lines @@
   bool will_begin_impl_frame_causes_redraw_;
   bool will_begin_impl_frame_requests_one_begin_impl_frame_;
   bool draw_will_happen_;
   bool swap_will_happen_if_draw_happens_;
   bool automatic_swap_ack_;
   int num_draws_;
   BeginFrameArgs begin_frame_args_sent_to_children_;
   BeginFrameArgs last_begin_main_frame_args_;
   base::TimeTicks posted_begin_impl_frame_deadline_;
   std::vector<const char*> actions_;
-  std::vector<scoped_ptr<base::trace_event::ConvertableToTraceFormat>> states_;
+  std::vector<std::unique_ptr<base::trace_event::ConvertableToTraceFormat>>
+      states_;
   TestScheduler* scheduler_;
 };
 
 class FakeExternalBeginFrameSource : public BeginFrameSourceBase {
  public:
   explicit FakeExternalBeginFrameSource(FakeSchedulerClient* client)
       : client_(client) {}
   ~FakeExternalBeginFrameSource() override {}
 
   void AddObserver(BeginFrameObserver* obs) override {
@@ skipping 43 matching lines @@
     synthetic_frame_source_.reset(new TestSyntheticBeginFrameSource(
         now_src_.get(), task_runner_.get(), BeginFrameArgs::DefaultInterval()));
     if (!scheduler_settings_.throttle_frame_production) {
       frame_source = unthrottled_frame_source_.get();
     } else if (scheduler_settings_.use_external_begin_frame_source) {
       frame_source = fake_external_begin_frame_source_.get();
     } else {
       frame_source = synthetic_frame_source_.get();
     }
 
-    scoped_ptr<FakeCompositorTimingHistory> fake_compositor_timing_history =
-        FakeCompositorTimingHistory::Create(
+    std::unique_ptr<FakeCompositorTimingHistory>
+        fake_compositor_timing_history = FakeCompositorTimingHistory::Create(
             scheduler_settings_.using_synchronous_renderer_compositor);
     fake_compositor_timing_history_ = fake_compositor_timing_history.get();
 
     scheduler_.reset(
         new TestScheduler(now_src_.get(), client_.get(), scheduler_settings_, 0,
                           task_runner_.get(), frame_source,
                           std::move(fake_compositor_timing_history)));
     DCHECK(scheduler_);
     client_->set_scheduler(scheduler_.get());
 
     // Use large estimates by default to avoid latency recovery in most tests.
     fake_compositor_timing_history_->SetAllEstimatesTo(kSlowDuration);
 
     return scheduler_.get();
   }
 
   void CreateSchedulerAndInitSurface() {
     CreateScheduler();
     EXPECT_SCOPED(InitializeOutputSurfaceAndFirstCommit());
   }
 
   void SetUpScheduler(bool initSurface) {
-    SetUpScheduler(make_scoped_ptr(new FakeSchedulerClient), initSurface);
+    SetUpScheduler(base::WrapUnique(new FakeSchedulerClient), initSurface);
   }
 
-  void SetUpScheduler(scoped_ptr<FakeSchedulerClient> client,
+  void SetUpScheduler(std::unique_ptr<FakeSchedulerClient> client,
                       bool initSurface) {
     client_ = std::move(client);
     if (initSurface)
       CreateSchedulerAndInitSurface();
     else
       CreateScheduler();
   }
 
   OrderedSimpleTaskRunner& task_runner() { return *task_runner_; }
   base::SimpleTestTickClock* now_src() { return now_src_.get(); }
@@ skipping 118 matching lines @@
   void ImplFrameNotSkippedAfterLateSwapAck();
   void BeginFramesNotFromClient(bool use_external_begin_frame_source,
                                 bool throttle_frame_production);
   void BeginFramesNotFromClient_SwapThrottled(
       bool use_external_begin_frame_source,
       bool throttle_frame_production);
   bool BeginMainFrameOnCriticalPath(TreePriority tree_priority,
                                     ScrollHandlerState scroll_handler_state,
                                     base::TimeDelta durations);
 
-  scoped_ptr<base::SimpleTestTickClock> now_src_;
+  std::unique_ptr<base::SimpleTestTickClock> now_src_;
   scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
-  scoped_ptr<FakeExternalBeginFrameSource> fake_external_begin_frame_source_;
-  scoped_ptr<TestSyntheticBeginFrameSource> synthetic_frame_source_;
-  scoped_ptr<TestBackToBackBeginFrameSource> unthrottled_frame_source_;
+  std::unique_ptr<FakeExternalBeginFrameSource>
+      fake_external_begin_frame_source_;
+  std::unique_ptr<TestSyntheticBeginFrameSource> synthetic_frame_source_;
+  std::unique_ptr<TestBackToBackBeginFrameSource> unthrottled_frame_source_;
   SchedulerSettings scheduler_settings_;
-  scoped_ptr<FakeSchedulerClient> client_;
-  scoped_ptr<TestScheduler> scheduler_;
+  std::unique_ptr<FakeSchedulerClient> client_;
+  std::unique_ptr<TestScheduler> scheduler_;
   FakeCompositorTimingHistory* fake_compositor_timing_history_;
 };
 
 TEST_F(SchedulerTest, InitializeOutputSurfaceDoesNotBeginImplFrame) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(false);
   scheduler_->SetVisible(true);
   scheduler_->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_);
@@ skipping 319 matching lines @@
 };
 
 // Tests for two different situations:
 // 1. the scheduler dropping SetNeedsRedraw requests that happen inside
 //    a ScheduledActionDrawAndSwap
 // 2. the scheduler drawing twice inside a single tick
 TEST_F(SchedulerTest, RequestRedrawInsideDraw) {
   SchedulerClientThatsetNeedsDrawInsideDraw* client =
       new SchedulerClientThatsetNeedsDrawInsideDraw;
   scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(make_scoped_ptr(client), true);
+  SetUpScheduler(base::WrapUnique(client), true);
   client->SetRequestRedrawsInsideDraw(true);
 
   scheduler_->SetNeedsRedraw();
   EXPECT_TRUE(scheduler_->RedrawPending());
   EXPECT_TRUE(client->needs_begin_frames());
   EXPECT_EQ(0, client->num_draws());
 
   EXPECT_SCOPED(AdvanceFrame());
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client->num_draws());
@@ skipping 15 matching lines @@
   EXPECT_EQ(2, client->num_draws());
   EXPECT_FALSE(scheduler_->RedrawPending());
   EXPECT_FALSE(client->needs_begin_frames());
 }
 
 // Test that requesting redraw inside a failed draw doesn't lose the request.
 TEST_F(SchedulerTest, RequestRedrawInsideFailedDraw) {
   SchedulerClientThatsetNeedsDrawInsideDraw* client =
       new SchedulerClientThatsetNeedsDrawInsideDraw;
   scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(make_scoped_ptr(client), true);
+  SetUpScheduler(base::WrapUnique(client), true);
 
   client->SetRequestRedrawsInsideDraw(true);
   client->SetDrawWillHappen(false);
 
   scheduler_->SetNeedsRedraw();
   EXPECT_TRUE(scheduler_->RedrawPending());
   EXPECT_TRUE(client->needs_begin_frames());
   EXPECT_EQ(0, client->num_draws());
 
   // Fail the draw.
@@ skipping 55 matching lines @@
   bool set_needs_commit_on_next_draw_;
 };
 
 // Tests for the scheduler infinite-looping on SetNeedsBeginMainFrame requests
 // that happen inside a ScheduledActionDrawAndSwap
 TEST_F(SchedulerTest, RequestCommitInsideDraw) {
   SchedulerClientThatSetNeedsBeginMainFrameInsideDraw* client =
       new SchedulerClientThatSetNeedsBeginMainFrameInsideDraw;
 
   scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(make_scoped_ptr(client), true);
+  SetUpScheduler(base::WrapUnique(client), true);
 
   EXPECT_FALSE(client->needs_begin_frames());
   scheduler_->SetNeedsRedraw();
   EXPECT_TRUE(scheduler_->RedrawPending());
   EXPECT_EQ(0, client->num_draws());
   EXPECT_TRUE(client->needs_begin_frames());
 
   client->SetNeedsBeginMainFrameOnNextDraw();
   EXPECT_SCOPED(AdvanceFrame());
   client->SetNeedsBeginMainFrameOnNextDraw();
@@ skipping 21 matching lines @@
   EXPECT_FALSE(scheduler_->RedrawPending());
   EXPECT_FALSE(scheduler_->CommitPending());
   EXPECT_FALSE(client->needs_begin_frames());
 }
 
 // Tests that when a draw fails then the pending commit should not be dropped.
 TEST_F(SchedulerTest, RequestCommitInsideFailedDraw) {
   SchedulerClientThatsetNeedsDrawInsideDraw* client =
       new SchedulerClientThatsetNeedsDrawInsideDraw;
   scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(make_scoped_ptr(client), true);
+  SetUpScheduler(base::WrapUnique(client), true);
 
   client->SetDrawWillHappen(false);
 
   scheduler_->SetNeedsRedraw();
   EXPECT_TRUE(scheduler_->RedrawPending());
   EXPECT_TRUE(client->needs_begin_frames());
   EXPECT_EQ(0, client->num_draws());
 
   // Fail the draw.
   EXPECT_SCOPED(AdvanceFrame());
@@ skipping 22 matching lines @@
   EXPECT_EQ(3, client->num_draws());
   EXPECT_TRUE(scheduler_->CommitPending());
   EXPECT_FALSE(scheduler_->RedrawPending());
   EXPECT_TRUE(client->needs_begin_frames());
 }
 
 TEST_F(SchedulerTest, NoSwapWhenDrawFails) {
   SchedulerClientThatSetNeedsBeginMainFrameInsideDraw* client =
       new SchedulerClientThatSetNeedsBeginMainFrameInsideDraw;
   scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(make_scoped_ptr(client), true);
+  SetUpScheduler(base::WrapUnique(client), true);
 
   scheduler_->SetNeedsRedraw();
   EXPECT_TRUE(scheduler_->RedrawPending());
   EXPECT_TRUE(client->needs_begin_frames());
   EXPECT_EQ(0, client->num_draws());
 
   // Draw successfully, this starts a new frame.
   client->SetNeedsBeginMainFrameOnNextDraw();
   EXPECT_SCOPED(AdvanceFrame());
   task_runner().RunPendingTasks();  // Run posted deadline.
@@ skipping 17 matching lines @@
     scheduler_->SetNeedsPrepareTiles();
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 };
 
 // Test prepare tiles is independant of draws.
 TEST_F(SchedulerTest, PrepareTiles) {
   SchedulerClientNeedsPrepareTilesInDraw* client =
       new SchedulerClientNeedsPrepareTilesInDraw;
   scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(make_scoped_ptr(client), true);
+  SetUpScheduler(base::WrapUnique(client), true);
 
   // Request both draw and prepare tiles. PrepareTiles shouldn't
   // be trigged until BeginImplFrame.
   client->Reset();
   scheduler_->SetNeedsPrepareTiles();
   scheduler_->SetNeedsRedraw();
   EXPECT_TRUE(scheduler_->RedrawPending());
   EXPECT_TRUE(scheduler_->PrepareTilesPending());
   EXPECT_TRUE(client->needs_begin_frames());
   EXPECT_EQ(0, client->num_draws());
@@ skipping 189 matching lines @@
   EXPECT_TRUE(client_->HasAction("ScheduledActionDrawAndSwapIfPossible"));
   EXPECT_TRUE(client_->HasAction("ScheduledActionPrepareTiles"));
   EXPECT_LT(client_->ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
             client_->ActionIndex("ScheduledActionPrepareTiles"));
   EXPECT_FALSE(scheduler_->RedrawPending());
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
   EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
 }
 
 TEST_F(SchedulerTest, PrepareTilesFunnelResetOnVisibilityChange) {
-  scoped_ptr<SchedulerClientNeedsPrepareTilesInDraw> client =
-      make_scoped_ptr(new SchedulerClientNeedsPrepareTilesInDraw);
+  std::unique_ptr<SchedulerClientNeedsPrepareTilesInDraw> client =
+      base::WrapUnique(new SchedulerClientNeedsPrepareTilesInDraw);
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(std::move(client), true);
 
   // Simulate a few visibility changes and associated PrepareTiles.
   for (int i = 0; i < 10; i++) {
     scheduler_->SetVisible(false);
     scheduler_->WillPrepareTiles();
     scheduler_->DidPrepareTiles();
 
     scheduler_->SetVisible(true);
@@ skipping 14 matching lines @@
   task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
   EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionPrepareTiles", client_, 1, 2);
 }
 
 TEST_F(SchedulerTest, TriggerBeginFrameDeadlineEarly) {
   SchedulerClientNeedsPrepareTilesInDraw* client =
       new SchedulerClientNeedsPrepareTilesInDraw;
   scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(make_scoped_ptr(client), true);
+  SetUpScheduler(base::WrapUnique(client), true);
 
   scheduler_->SetNeedsRedraw();
   EXPECT_SCOPED(AdvanceFrame());
 
   // The deadline should be zero since there is no work other than drawing
   // pending.
   EXPECT_EQ(base::TimeTicks(), client->posted_begin_impl_frame_deadline());
 }
 
 TEST_F(SchedulerTest, WaitForReadyToDrawDoNotPostDeadline) {
   SchedulerClientNeedsPrepareTilesInDraw* client =
       new SchedulerClientNeedsPrepareTilesInDraw;
   scheduler_settings_.use_external_begin_frame_source = true;
   scheduler_settings_.commit_to_active_tree = true;
-  SetUpScheduler(make_scoped_ptr(client), true);
+  SetUpScheduler(base::WrapUnique(client), true);
 
   // SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   // Begin new frame.
   EXPECT_SCOPED(AdvanceFrame());
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
@@ skipping 19 matching lines @@
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client_->num_draws());
   EXPECT_TRUE(client_->HasAction("ScheduledActionDrawAndSwapIfPossible"));
 }
 
 TEST_F(SchedulerTest, WaitForReadyToDrawCancelledWhenLostOutputSurface) {
   SchedulerClientNeedsPrepareTilesInDraw* client =
       new SchedulerClientNeedsPrepareTilesInDraw;
   scheduler_settings_.use_external_begin_frame_source = true;
   scheduler_settings_.commit_to_active_tree = true;
-  SetUpScheduler(make_scoped_ptr(client), true);
+  SetUpScheduler(base::WrapUnique(client), true);
 
   // SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame.
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   // Begin new frame.
   EXPECT_SCOPED(AdvanceFrame());
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
@@ skipping 2203 matching lines @@
   DrawResult ScheduledActionDrawAndSwapIfPossible() override {
     scheduler_->SetNeedsPrepareTiles();
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 };
 
 TEST_F(SchedulerTest, SynchronousCompositorPrepareTilesOnDraw) {
   scheduler_settings_.using_synchronous_renderer_compositor = true;
   scheduler_settings_.use_external_begin_frame_source = true;
 
-  scoped_ptr<FakeSchedulerClient> client =
-      make_scoped_ptr(new SchedulerClientSetNeedsPrepareTilesOnDraw);
+  std::unique_ptr<FakeSchedulerClient> client =
+      base::WrapUnique(new SchedulerClientSetNeedsPrepareTilesOnDraw);
   SetUpScheduler(std::move(client), true);
 
   scheduler_->SetNeedsRedraw();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   // Next vsync.
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionInvalidateOutputSurface", client_, 1, 2);
@@ skipping 291 matching lines @@
 }
 
 TEST_F(SchedulerTest, BeginMainFrameOnCriticalPath_AHS) {
   EXPECT_FALSE(BeginMainFrameOnCriticalPath(
       SMOOTHNESS_TAKES_PRIORITY,
       ScrollHandlerState::SCROLL_AFFECTS_SCROLL_HANDLER, kSlowDuration));
 }
 
 }  // namespace
 }  // namespace cc