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

cc/scheduler/begin_frame_source_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/begin_frame_source.h"
 
 #include <stdint.h>
 
+#include "base/memory/ptr_util.h"
 #include "base/test/test_simple_task_runner.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "cc/test/begin_frame_source_test.h"
 #include "cc/test/scheduler_test_common.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::Mock;
 using testing::StrictMock;
 
@@ skipping 173 matching lines @@
   void OnBeginFrameSourcePausedChanged(bool paused) override {}
 };
 
 TEST(BeginFrameSourceBaseTest, DetectAsValueIntoLoop) {
   LoopingBeginFrameObserver obs;
   FakeBeginFrameSource source;
 
   obs.source_ = &source;
   source.AddObserver(&obs);
 
-  scoped_ptr<base::trace_event::TracedValue> state(
+  std::unique_ptr<base::trace_event::TracedValue> state(
       new base::trace_event::TracedValue());
   source.AsValueInto(state.get());
 }
 
 // BackToBackBeginFrameSource testing -----------------------------------------
 class TestBackToBackBeginFrameSource : public BackToBackBeginFrameSource {
  public:
   TestBackToBackBeginFrameSource(base::SimpleTestTickClock* now_src,
                                  base::SingleThreadTaskRunner* task_runner)
       : BackToBackBeginFrameSource(task_runner), now_src_(now_src) {}
 
  protected:
   base::TimeTicks Now() override { return now_src_->NowTicks(); }
 
   // Not owned.
   base::SimpleTestTickClock* now_src_;
 };
 
 class BackToBackBeginFrameSourceTest : public ::testing::Test {
  public:
   static const int64_t kDeadline;
   static const int64_t kInterval;
 
-  scoped_ptr<base::SimpleTestTickClock> now_src_;
+  std::unique_ptr<base::SimpleTestTickClock> now_src_;
   scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
-  scoped_ptr<TestBackToBackBeginFrameSource> source_;
-  scoped_ptr<MockBeginFrameObserver> obs_;
+  std::unique_ptr<TestBackToBackBeginFrameSource> source_;
+  std::unique_ptr<MockBeginFrameObserver> obs_;
 
   void SetUp() override {
     now_src_.reset(new base::SimpleTestTickClock());
     now_src_->Advance(base::TimeDelta::FromMicroseconds(1000));
     task_runner_ =
         make_scoped_refptr(new OrderedSimpleTaskRunner(now_src_.get(), false));
     source_.reset(
         new TestBackToBackBeginFrameSource(now_src_.get(), task_runner_.get()));
-    obs_ = make_scoped_ptr(new ::testing::StrictMock<MockBeginFrameObserver>());
+    obs_ =
+        base::WrapUnique(new ::testing::StrictMock<MockBeginFrameObserver>());
   }
 
   void TearDown() override { obs_.reset(); }
 };
 
 const int64_t BackToBackBeginFrameSourceTest::kDeadline =
     BeginFrameArgs::DefaultInterval().ToInternalValue();
 
 const int64_t BackToBackBeginFrameSourceTest::kInterval =
     BeginFrameArgs::DefaultInterval().ToInternalValue();
@@ skipping 146 matching lines @@
   now_src_->Advance(base::TimeDelta::FromMicroseconds(50));
   EXPECT_BEGIN_FRAME_USED(*obs_, 1150, 1150 + kDeadline, kInterval);
 
   EXPECT_TRUE(task_runner_->HasPendingTasks());
   task_runner_->RunPendingTasks();
 }
 
 // SyntheticBeginFrameSource testing ------------------------------------------
 class SyntheticBeginFrameSourceTest : public ::testing::Test {
  public:
-  scoped_ptr<base::SimpleTestTickClock> now_src_;
+  std::unique_ptr<base::SimpleTestTickClock> now_src_;
   scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
-  scoped_ptr<TestSyntheticBeginFrameSource> source_;
-  scoped_ptr<MockBeginFrameObserver> obs_;
+  std::unique_ptr<TestSyntheticBeginFrameSource> source_;
+  std::unique_ptr<MockBeginFrameObserver> obs_;
 
   void SetUp() override {
     now_src_.reset(new base::SimpleTestTickClock());
     now_src_->Advance(base::TimeDelta::FromMicroseconds(1000));
     task_runner_ =
         make_scoped_refptr(new OrderedSimpleTaskRunner(now_src_.get(), false));
     source_.reset(new TestSyntheticBeginFrameSource(
         now_src_.get(), task_runner_.get(),
         base::TimeDelta::FromMicroseconds(10000)));
-    obs_ = make_scoped_ptr(new MockBeginFrameObserver());
+    obs_ = base::WrapUnique(new MockBeginFrameObserver());
   }
 
   void TearDown() override { obs_.reset(); }
 };
 
 TEST_F(SyntheticBeginFrameSourceTest,
        AddObserverCallsOnBeginFrameWithMissedTick) {
   now_src_->Advance(base::TimeDelta::FromMicroseconds(9010));
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, 10000, 20000, 10000);
@@ skipping 125 matching lines @@
                                    base::TimeDelta::FromInternalValue(10000));
   now_src_->Advance(base::TimeDelta::FromInternalValue(5000));
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs, false);
   EXPECT_BEGIN_FRAME_USED_MISSED(obs, 10000, 20000, 10000);
   source_->AddObserver(&obs);
   source_->RemoveObserver(&obs);
 }
 
 }  // namespace
 }  // namespace cc