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

chrome/browser/sync_file_system/drive_backend/sync_task_manager_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/drive_backend/sync_task_manager.h"
 
 #include <stdint.h>
 #include <deque>
 #include <string>
 #include <utility>
@@ skipping 64 matching lines @@
   }
   ~TaskManagerClient() override {}
 
   // DriveFileSyncManager::Client overrides.
   void MaybeScheduleNextTask() override { ++maybe_schedule_next_task_count_; }
   void NotifyLastOperationStatus(SyncStatusCode last_operation_status,
                                  bool last_operation_used_network) override {
     last_operation_status_ = last_operation_status;
   }
 
-  void RecordTaskLog(scoped_ptr<TaskLogger::TaskLog>) override {}
+  void RecordTaskLog(std::unique_ptr<TaskLogger::TaskLog>) override {}
 
   void ScheduleTask(SyncStatusCode status_to_return,
                     const SyncStatusCallback& callback) {
     task_manager_->ScheduleTask(
         FROM_HERE,
         base::Bind(&TaskManagerClient::DoTask, AsWeakPtr(),
                    status_to_return, false /* idle */),
         SyncTaskManager::PRIORITY_MED,
         callback);
   }
@@ skipping 19 matching lines @@
   void DoTask(SyncStatusCode status_to_return,
               bool is_idle_task,
               const SyncStatusCallback& callback) {
     ++task_scheduled_count_;
     if (is_idle_task)
       ++idle_task_scheduled_count_;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, status_to_return));
   }
 
-  scoped_ptr<SyncTaskManager> task_manager_;
+  std::unique_ptr<SyncTaskManager> task_manager_;
 
   int maybe_schedule_next_task_count_;
   int task_scheduled_count_;
   int idle_task_scheduled_count_;
 
   SyncStatusCode last_operation_status_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskManagerClient);
 };
 
@@ skipping 50 matching lines @@
                  const base::FilePath& path,
                  Stats* stats)
       : app_id_(app_id),
         path_(path),
         stats_(stats),
         weak_ptr_factory_(this) {
   }
 
   ~BackgroundTask() override {}
 
-  void RunPreflight(scoped_ptr<SyncTaskToken> token) override {
-    scoped_ptr<TaskBlocker> task_blocker(new TaskBlocker);
+  void RunPreflight(std::unique_ptr<SyncTaskToken> token) override {
+    std::unique_ptr<TaskBlocker> task_blocker(new TaskBlocker);
     task_blocker->app_id = app_id_;
     task_blocker->paths.push_back(path_);
 
     SyncTaskManager::UpdateTaskBlocker(
         std::move(token), std::move(task_blocker),
         base::Bind(&BackgroundTask::RunAsBackgroundTask,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
  private:
-  void RunAsBackgroundTask(scoped_ptr<SyncTaskToken> token) {
+  void RunAsBackgroundTask(std::unique_ptr<SyncTaskToken> token) {
     ++(stats_->running_background_task);
     if (stats_->max_parallel_task < stats_->running_background_task)
       stats_->max_parallel_task = stats_->running_background_task;
 
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&BackgroundTask::CompleteTask,
                    weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
   }
 
-  void CompleteTask(scoped_ptr<SyncTaskToken> token) {
+  void CompleteTask(std::unique_ptr<SyncTaskToken> token) {
     ++(stats_->finished_task);
     --(stats_->running_background_task);
     SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_OK);
   }
 
   std::string app_id_;
   base::FilePath path_;
   Stats* stats_;
 
   base::WeakPtrFactory<BackgroundTask> weak_ptr_factory_;
@@ skipping 11 matching lines @@
                           Log* log)
       : name_(name),
         app_id_(app_id),
         paths_(paths.begin(), paths.end()),
         log_(log),
         weak_ptr_factory_(this) {
   }
 
   ~BlockerUpdateTestHelper() override {}
 
-  void RunPreflight(scoped_ptr<SyncTaskToken> token) override {
+  void RunPreflight(std::unique_ptr<SyncTaskToken> token) override {
     UpdateBlocker(std::move(token));
   }
 
  private:
-  void UpdateBlocker(scoped_ptr<SyncTaskToken> token) {
+  void UpdateBlocker(std::unique_ptr<SyncTaskToken> token) {
     if (paths_.empty()) {
       log_->push_back(name_ + ": finished");
       SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_OK);
       return;
     }
 
     std::string updating_to = paths_.front();
     paths_.pop_front();
 
     log_->push_back(name_ + ": updating to " + updating_to);
 
-    scoped_ptr<TaskBlocker> task_blocker(new TaskBlocker);
+    std::unique_ptr<TaskBlocker> task_blocker(new TaskBlocker);
     task_blocker->app_id = app_id_;
     task_blocker->paths.push_back(
         base::FilePath(storage::VirtualPath::GetNormalizedFilePath(
             base::FilePath::FromUTF8Unsafe(updating_to))));
 
     SyncTaskManager::UpdateTaskBlocker(
         std::move(token), std::move(task_blocker),
         base::Bind(&BlockerUpdateTestHelper::UpdateBlockerSoon,
                    weak_ptr_factory_.GetWeakPtr(), updating_to));
   }
 
   void UpdateBlockerSoon(const std::string& updated_to,
-                         scoped_ptr<SyncTaskToken> token) {
+                         std::unique_ptr<SyncTaskToken> token) {
     log_->push_back(name_ + ": updated to " + updated_to);
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&BlockerUpdateTestHelper::UpdateBlocker,
                    weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
   }
 
   std::string name_;
   std::string app_id_;
   std::deque<std::string> paths_;
@@ skipping 102 matching lines @@
   bool task_completed = false;
 
   {
     SyncTaskManager task_manager(base::WeakPtr<SyncTaskManager::Client>(),
                                  0 /* maximum_background_task */,
                                  base::ThreadTaskRunnerHandle::Get(),
                                  nullptr /* worker_pool */);
     task_manager.Initialize(SYNC_STATUS_OK);
     message_loop.RunUntilIdle();
     task_manager.ScheduleSyncTask(
-        FROM_HERE,
-        scoped_ptr<SyncTask>(new MultihopSyncTask(
-            &task_started, &task_completed)),
+        FROM_HERE, std::unique_ptr<SyncTask>(
+                       new MultihopSyncTask(&task_started, &task_completed)),
         SyncTaskManager::PRIORITY_MED,
         base::Bind(&IncrementAndAssign, 0, &callback_count, &status));
   }
   message_loop.RunUntilIdle();
 
   EXPECT_EQ(0, callback_count);
   EXPECT_EQ(SYNC_STATUS_UNKNOWN, status);
   EXPECT_TRUE(task_started);
   EXPECT_FALSE(task_completed);
 }
@@ skipping 64 matching lines @@
   base::MessageLoop message_loop;
   SyncTaskManager task_manager(base::WeakPtr<SyncTaskManager::Client>(),
                                10 /* maximum_background_task */,
                                base::ThreadTaskRunnerHandle::Get(),
                                nullptr /* worker_pool */);
   task_manager.Initialize(SYNC_STATUS_OK);
 
   SyncStatusCode status = SYNC_STATUS_FAILED;
   BackgroundTask::Stats stats;
   task_manager.ScheduleSyncTask(
-      FROM_HERE,
-      scoped_ptr<SyncTask>(new BackgroundTask(
-          "app_id", MAKE_PATH("/hoge/fuga"),
-          &stats)),
-      SyncTaskManager::PRIORITY_MED,
-      CreateResultReceiver(&status));
+      FROM_HERE, std::unique_ptr<SyncTask>(new BackgroundTask(
+                     "app_id", MAKE_PATH("/hoge/fuga"), &stats)),
+      SyncTaskManager::PRIORITY_MED, CreateResultReceiver(&status));
 
   task_manager.ScheduleSyncTask(
-      FROM_HERE,
-      scoped_ptr<SyncTask>(new BackgroundTask(
-          "app_id", MAKE_PATH("/hoge"),
-          &stats)),
-      SyncTaskManager::PRIORITY_MED,
-      CreateResultReceiver(&status));
+      FROM_HERE, std::unique_ptr<SyncTask>(
+                     new BackgroundTask("app_id", MAKE_PATH("/hoge"), &stats)),
+      SyncTaskManager::PRIORITY_MED, CreateResultReceiver(&status));
 
   task_manager.ScheduleSyncTask(
-      FROM_HERE,
-      scoped_ptr<SyncTask>(new BackgroundTask(
-          "app_id", MAKE_PATH("/hoge/fuga/piyo"),
-          &stats)),
-      SyncTaskManager::PRIORITY_MED,
-      CreateResultReceiver(&status));
+      FROM_HERE, std::unique_ptr<SyncTask>(new BackgroundTask(
+                     "app_id", MAKE_PATH("/hoge/fuga/piyo"), &stats)),
+      SyncTaskManager::PRIORITY_MED, CreateResultReceiver(&status));
 
   message_loop.RunUntilIdle();
 
   EXPECT_EQ(SYNC_STATUS_OK, status);
   EXPECT_EQ(0, stats.running_background_task);
   EXPECT_EQ(3, stats.finished_task);
   EXPECT_EQ(1, stats.max_parallel_task);
 }
 
 TEST(SyncTaskManagerTest, BackgroundTask_Parallel) {
   base::MessageLoop message_loop;
   SyncTaskManager task_manager(base::WeakPtr<SyncTaskManager::Client>(),
                                10 /* maximum_background_task */,
                                base::ThreadTaskRunnerHandle::Get(),
                                nullptr /* worker_pool */);
   task_manager.Initialize(SYNC_STATUS_OK);
 
   SyncStatusCode status = SYNC_STATUS_FAILED;
   BackgroundTask::Stats stats;
   task_manager.ScheduleSyncTask(
-      FROM_HERE,
-      scoped_ptr<SyncTask>(new BackgroundTask(
-          "app_id", MAKE_PATH("/hoge"),
-          &stats)),
-      SyncTaskManager::PRIORITY_MED,
-      CreateResultReceiver(&status));
+      FROM_HERE, std::unique_ptr<SyncTask>(
+                     new BackgroundTask("app_id", MAKE_PATH("/hoge"), &stats)),
+      SyncTaskManager::PRIORITY_MED, CreateResultReceiver(&status));
 
   task_manager.ScheduleSyncTask(
-      FROM_HERE,
-      scoped_ptr<SyncTask>(new BackgroundTask(
-          "app_id", MAKE_PATH("/fuga"),
-          &stats)),
-      SyncTaskManager::PRIORITY_MED,
-      CreateResultReceiver(&status));
+      FROM_HERE, std::unique_ptr<SyncTask>(
+                     new BackgroundTask("app_id", MAKE_PATH("/fuga"), &stats)),
+      SyncTaskManager::PRIORITY_MED, CreateResultReceiver(&status));
 
   task_manager.ScheduleSyncTask(
-      FROM_HERE,
-      scoped_ptr<SyncTask>(new BackgroundTask(
-          "app_id", MAKE_PATH("/piyo"),
-          &stats)),
-      SyncTaskManager::PRIORITY_MED,
-      CreateResultReceiver(&status));
+      FROM_HERE, std::unique_ptr<SyncTask>(
+                     new BackgroundTask("app_id", MAKE_PATH("/piyo"), &stats)),
+      SyncTaskManager::PRIORITY_MED, CreateResultReceiver(&status));
 
   message_loop.RunUntilIdle();
 
   EXPECT_EQ(SYNC_STATUS_OK, status);
   EXPECT_EQ(0, stats.running_background_task);
   EXPECT_EQ(3, stats.finished_task);
   EXPECT_EQ(3, stats.max_parallel_task);
 }
 
 TEST(SyncTaskManagerTest, BackgroundTask_Throttled) {
   base::MessageLoop message_loop;
   SyncTaskManager task_manager(base::WeakPtr<SyncTaskManager::Client>(),
                                2 /* maximum_background_task */,
                                base::ThreadTaskRunnerHandle::Get(),
                                nullptr /* worker_pool */);
   task_manager.Initialize(SYNC_STATUS_OK);
 
   SyncStatusCode status = SYNC_STATUS_FAILED;
   BackgroundTask::Stats stats;
   task_manager.ScheduleSyncTask(
-      FROM_HERE,
-      scoped_ptr<SyncTask>(new BackgroundTask(
-          "app_id", MAKE_PATH("/hoge"),
-          &stats)),
-      SyncTaskManager::PRIORITY_MED,
-      CreateResultReceiver(&status));
+      FROM_HERE, std::unique_ptr<SyncTask>(
+                     new BackgroundTask("app_id", MAKE_PATH("/hoge"), &stats)),
+      SyncTaskManager::PRIORITY_MED, CreateResultReceiver(&status));
 
   task_manager.ScheduleSyncTask(
-      FROM_HERE,
-      scoped_ptr<SyncTask>(new BackgroundTask(
-          "app_id", MAKE_PATH("/fuga"),
-          &stats)),
-      SyncTaskManager::PRIORITY_MED,
-      CreateResultReceiver(&status));
+      FROM_HERE, std::unique_ptr<SyncTask>(
+                     new BackgroundTask("app_id", MAKE_PATH("/fuga"), &stats)),
+      SyncTaskManager::PRIORITY_MED, CreateResultReceiver(&status));
 
   task_manager.ScheduleSyncTask(
-      FROM_HERE,
-      scoped_ptr<SyncTask>(new BackgroundTask(
-          "app_id", MAKE_PATH("/piyo"),
-          &stats)),
-      SyncTaskManager::PRIORITY_MED,
-      CreateResultReceiver(&status));
+      FROM_HERE, std::unique_ptr<SyncTask>(
+                     new BackgroundTask("app_id", MAKE_PATH("/piyo"), &stats)),
+      SyncTaskManager::PRIORITY_MED, CreateResultReceiver(&status));
 
   message_loop.RunUntilIdle();
 
   EXPECT_EQ(SYNC_STATUS_OK, status);
   EXPECT_EQ(0, stats.running_background_task);
   EXPECT_EQ(3, stats.finished_task);
   EXPECT_EQ(2, stats.max_parallel_task);
 }
 
 TEST(SyncTaskManagerTest, UpdateTaskBlocker) {
   base::MessageLoop message_loop;
   SyncTaskManager task_manager(base::WeakPtr<SyncTaskManager::Client>(),
                                10 /* maximum_background_task */,
                                base::ThreadTaskRunnerHandle::Get(),
                                nullptr /* worker_pool */);
   task_manager.Initialize(SYNC_STATUS_OK);
 
   SyncStatusCode status1 = SYNC_STATUS_FAILED;
   SyncStatusCode status2 = SYNC_STATUS_FAILED;
   BlockerUpdateTestHelper::Log log;
 
   {
     std::vector<std::string> paths;
     paths.push_back("/foo/bar");
     paths.push_back("/foo");
     paths.push_back("/hoge/fuga/piyo");
     task_manager.ScheduleSyncTask(
-        FROM_HERE,
-        scoped_ptr<SyncTask>(new BlockerUpdateTestHelper(
-            "task1", "app_id", paths, &log)),
-        SyncTaskManager::PRIORITY_MED,
-        CreateResultReceiver(&status1));
+        FROM_HERE, std::unique_ptr<SyncTask>(new BlockerUpdateTestHelper(
+                       "task1", "app_id", paths, &log)),
+        SyncTaskManager::PRIORITY_MED, CreateResultReceiver(&status1));
   }
 
   {
     std::vector<std::string> paths;
     paths.push_back("/foo");
     paths.push_back("/foo/bar");
     paths.push_back("/hoge/fuga/piyo");
     task_manager.ScheduleSyncTask(
-        FROM_HERE,
-        scoped_ptr<SyncTask>(new BlockerUpdateTestHelper(
-            "task2", "app_id", paths, &log)),
-        SyncTaskManager::PRIORITY_MED,
-        CreateResultReceiver(&status2));
+        FROM_HERE, std::unique_ptr<SyncTask>(new BlockerUpdateTestHelper(
+                       "task2", "app_id", paths, &log)),
+        SyncTaskManager::PRIORITY_MED, CreateResultReceiver(&status2));
   }
 
   message_loop.RunUntilIdle();
 
   EXPECT_EQ(SYNC_STATUS_OK, status1);
   EXPECT_EQ(SYNC_STATUS_OK, status2);
 
   ASSERT_EQ(14u, log.size());
   int i = 0;
 
@@ skipping 20 matching lines @@
 
   EXPECT_EQ("task1: finished", log[i++]);
 
   EXPECT_EQ("task2: updating to /hoge/fuga/piyo", log[i++]);
   EXPECT_EQ("task2: updated to /hoge/fuga/piyo", log[i++]);
   EXPECT_EQ("task2: finished", log[i++]);
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system