Convert Pass()→std::move() in //chrome/browser/ui

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>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_task.h"
-#include "chrome/browser/sync_file_system/drive_backend/sync_task_manager.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_task_token.h"
 #include "chrome/browser/sync_file_system/sync_file_system_test_util.h"
 #include "storage/common/fileapi/file_system_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #define MAKE_PATH(path)                                       \
   base::FilePath(storage::VirtualPath::GetNormalizedFilePath( \
       base::FilePath(FILE_PATH_LITERAL(path))))
 
 namespace sync_file_system {
@@ skipping 161 matching lines @@
   }
 
   ~BackgroundTask() override {}
 
   void RunPreflight(scoped_ptr<SyncTaskToken> token) override {
     scoped_ptr<TaskBlocker> task_blocker(new TaskBlocker);
     task_blocker->app_id = app_id_;
     task_blocker->paths.push_back(path_);
 
     SyncTaskManager::UpdateTaskBlocker(
-        token.Pass(), task_blocker.Pass(),
+        std::move(token), std::move(task_blocker),
         base::Bind(&BackgroundTask::RunAsBackgroundTask,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
  private:
   void RunAsBackgroundTask(scoped_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) {
     ++(stats_->finished_task);
     --(stats_->running_background_task);
-    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_OK);
+    SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_OK);
   }
 
   std::string app_id_;
   base::FilePath path_;
   Stats* stats_;
 
   base::WeakPtrFactory<BackgroundTask> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundTask);
 };
 
 class BlockerUpdateTestHelper : public SyncTask {
  public:
   typedef std::vector<std::string> Log;
 
   BlockerUpdateTestHelper(const std::string& name,
                           const std::string& app_id,
                           const std::vector<std::string>& paths,
                           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 {
-    UpdateBlocker(token.Pass());
+    UpdateBlocker(std::move(token));
   }
 
  private:
   void UpdateBlocker(scoped_ptr<SyncTaskToken> token) {
     if (paths_.empty()) {
       log_->push_back(name_ + ": finished");
-      SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_OK);
+      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);
     task_blocker->app_id = app_id_;
     task_blocker->paths.push_back(
         base::FilePath(storage::VirtualPath::GetNormalizedFilePath(
             base::FilePath::FromUTF8Unsafe(updating_to))));
 
     SyncTaskManager::UpdateTaskBlocker(
-        token.Pass(), task_blocker.Pass(),
+        std::move(token), std::move(task_blocker),
         base::Bind(&BlockerUpdateTestHelper::UpdateBlockerSoon,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   updating_to));
+                   weak_ptr_factory_.GetWeakPtr(), updating_to));
   }
 
   void UpdateBlockerSoon(const std::string& updated_to,
                          scoped_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)));
   }
@@ skipping 384 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