Suppress sequence checks in SyncFileSystem on the shutdown phase

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 <deque>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 44 matching lines @@
     : public SyncTaskManager::Client,
       public base::SupportsWeakPtr<TaskManagerClient> {
  public:
   explicit TaskManagerClient(int64 maximum_background_task)
       : maybe_schedule_next_task_count_(0),
         task_scheduled_count_(0),
         idle_task_scheduled_count_(0),
         last_operation_status_(SYNC_STATUS_OK) {
     task_manager_.reset(new SyncTaskManager(
         AsWeakPtr(), maximum_background_task,
-        base::ThreadTaskRunnerHandle::Get()));
+        base::ThreadTaskRunnerHandle::Get(),
+        nullptr /* worker_pool */));
     task_manager_->Initialize(SYNC_STATUS_OK);
     base::MessageLoop::current()->RunUntilIdle();
     maybe_schedule_next_task_count_ = 0;
   }
   ~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 {
@@ skipping 309 matching lines @@
 
   int callback_count = 0;
   SyncStatusCode status = SYNC_STATUS_UNKNOWN;
 
   bool task_started = false;
   bool task_completed = false;
 
   {
     SyncTaskManager task_manager(base::WeakPtr<SyncTaskManager::Client>(),
                                  0 /* maximum_background_task */,
-                                 base::ThreadTaskRunnerHandle::Get());
+                                 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)),
         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);
 }
 
 TEST(SyncTaskManagerTest, ScheduleTaskAtPriority) {
   base::MessageLoop message_loop;
   SyncTaskManager task_manager(base::WeakPtr<SyncTaskManager::Client>(),
                                0 /* maximum_background_task */,
-                               base::ThreadTaskRunnerHandle::Get());
+                               base::ThreadTaskRunnerHandle::Get(),
+                               nullptr /* worker_pool */);
   task_manager.Initialize(SYNC_STATUS_OK);
   message_loop.RunUntilIdle();
 
   int callback_count = 0;
   SyncStatusCode callback_status1 = SYNC_STATUS_OK;
   SyncStatusCode callback_status2 = SYNC_STATUS_OK;
   SyncStatusCode callback_status3 = SYNC_STATUS_OK;
   SyncStatusCode callback_status4 = SYNC_STATUS_OK;
   SyncStatusCode callback_status5 = SYNC_STATUS_OK;
 
@@ skipping 40 matching lines @@
   EXPECT_EQ(kStatus3, callback_status3);
   EXPECT_EQ(kStatus4, callback_status4);
   EXPECT_EQ(kStatus5, callback_status5);
   EXPECT_EQ(5, callback_count);
 }
 
 TEST(SyncTaskManagerTest, BackgroundTask_Sequential) {
   base::MessageLoop message_loop;
   SyncTaskManager task_manager(base::WeakPtr<SyncTaskManager::Client>(),
                                10 /* maximum_background_task */,
-                               base::ThreadTaskRunnerHandle::Get());
+                               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,
@@ skipping 20 matching lines @@
   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());
+                               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,
@@ skipping 20 matching lines @@
   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());
+                               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,
@@ skipping 20 matching lines @@
   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());
+                               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");
@@ skipping 50 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