Convert //chrome/browser/sync_file_system from scoped_ptr to std::unique_ptr

chrome/browser/sync_file_system/sync_process_runner_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 "chrome/browser/sync_file_system/sync_process_runner.h"
 
 #include <stddef.h>
 #include <stdint.h>
+
+#include <memory>
 #include <queue>
 #include <utility>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace sync_file_system {
 
 namespace {
 
 class FakeClient : public SyncProcessRunner::Client {
  public:
   FakeClient() : service_state_(SYNC_SERVICE_RUNNING) {}
   ~FakeClient() override {}
@@ skipping 51 matching lines @@
   base::TimeTicks current_time_;
   base::TimeTicks scheduled_time_;
   base::Closure timer_task_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeTimerHelper);
 };
 
 class FakeSyncProcessRunner : public SyncProcessRunner {
  public:
   FakeSyncProcessRunner(SyncProcessRunner::Client* client,
-                        scoped_ptr<TimerHelper> timer_helper,
+                        std::unique_ptr<TimerHelper> timer_helper,
                         size_t max_parallel_task)
       : SyncProcessRunner("FakeSyncProcess",
                           client,
                           std::move(timer_helper),
                           max_parallel_task),
         max_parallel_task_(max_parallel_task) {}
 
   void StartSync(const SyncStatusCallback& callback) override {
     EXPECT_LT(running_tasks_.size(), max_parallel_task_);
     running_tasks_.push(callback);
@@ skipping 22 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(FakeSyncProcessRunner);
 };
 
 }  // namespace
 
 TEST(SyncProcessRunnerTest, SingleTaskBasicTest) {
   FakeClient fake_client;
   FakeTimerHelper* fake_timer = new FakeTimerHelper();
   FakeSyncProcessRunner fake_runner(
-      &fake_client,
-      scoped_ptr<SyncProcessRunner::TimerHelper>(fake_timer),
+      &fake_client, std::unique_ptr<SyncProcessRunner::TimerHelper>(fake_timer),
       1 /* max_parallel_task */);
 
   base::TimeTicks base_time = base::TimeTicks::Now();
   fake_timer->SetCurrentTime(base_time);
 
   // SyncProcessRunner is expected not to run a task  initially.
   EXPECT_FALSE(fake_timer->IsRunning());
 
   // As soon as SyncProcessRunner gets a new update, it should start running
   // the timer to run a synchronization task.
@@ skipping 49 matching lines @@
   fake_client.set_service_state(SYNC_SERVICE_AUTHENTICATION_REQUIRED);
   fake_runner.UpdateChanges(100);
   EXPECT_EQ(SyncProcessRunner::kSyncDelayMaxInMilliseconds,
             fake_timer->GetCurrentDelay());
 }
 
 TEST(SyncProcessRunnerTest, MultiTaskBasicTest) {
   FakeClient fake_client;
   FakeTimerHelper* fake_timer = new FakeTimerHelper();
   FakeSyncProcessRunner fake_runner(
-      &fake_client,
-      scoped_ptr<SyncProcessRunner::TimerHelper>(fake_timer),
+      &fake_client, std::unique_ptr<SyncProcessRunner::TimerHelper>(fake_timer),
       2 /* max_parallel_task */);
 
   base::TimeTicks base_time = base::TimeTicks::Now();
   fake_timer->SetCurrentTime(base_time);
 
   EXPECT_FALSE(fake_timer->IsRunning());
 
   fake_runner.UpdateChanges(100);
   EXPECT_TRUE(fake_timer->IsRunning());
   EXPECT_EQ(SyncProcessRunner::kSyncDelayFastInMilliseconds,
@@ skipping 52 matching lines @@
 
   // Then, following failing task should not extend throttling period.
   fake_timer->AdvanceToScheduledTime();
   fake_client.set_service_state(SYNC_SERVICE_TEMPORARY_UNAVAILABLE);
   fake_runner.CompleteTask(SYNC_STATUS_FAILED);
   EXPECT_EQ(SyncProcessRunner::kSyncDelaySlowInMilliseconds,
             fake_timer->GetCurrentDelay());
 }
 
 }  // namespace sync_file_system