[SyncFS] Make task invocation in SyncTaskRunner async

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 42 matching lines @@
 class TaskManagerClient
     : 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));
+        AsWeakPtr(), maximum_background_task,
+        base::MessageLoopProxy::current()));
     task_manager_->Initialize(SYNC_STATUS_OK);
+    base::MessageLoop::current()->RunUntilIdle();
     maybe_schedule_next_task_count_ = 0;
   }
   virtual ~TaskManagerClient() {}
 
   // DriveFileSyncManager::Client overrides.
   virtual void MaybeScheduleNextTask() OVERRIDE {
     ++maybe_schedule_next_task_count_;
   }
   virtual void NotifyLastOperationStatus(
       SyncStatusCode last_operation_status,
@@ skipping 311 matching lines @@
   base::MessageLoop message_loop;
 
   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 */);
+                                 0 /* maximum_background_task */,
+                                 base::MessageLoopProxy::current());
     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();
 
-  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 */);
+                               0 /* maximum_background_task */,
+                               base::MessageLoopProxy::current());
   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;
 
   // This will run first even if its priority is low, since there're no
   // pending tasks.
@@ skipping 37 matching lines @@
   EXPECT_EQ(kStatus2, callback_status2);
   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 */);
+                               10 /* maximum_background_task */,
+                               base::MessageLoopProxy::current());
   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 19 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 */);
+                               10 /* maximum_background_task */,
+                               base::MessageLoopProxy::current());
   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 19 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 */);
+                               2 /* maximum_background_task */,
+                               base::MessageLoopProxy::current());
   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 19 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, UpdateBlockingFactor) {
   base::MessageLoop message_loop;
   SyncTaskManager task_manager(base::WeakPtr<SyncTaskManager::Client>(),
-                               10 /* maximum_background_task */);
+                               10 /* maximum_background_task */,
+                               base::MessageLoopProxy::current());
   task_manager.Initialize(SYNC_STATUS_OK);
 
-  SyncStatusCode status = SYNC_STATUS_FAILED;
+  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(&status));
+        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(&status));
+        CreateResultReceiver(&status2));
   }
 
   message_loop.RunUntilIdle();
 
-  EXPECT_EQ(SYNC_STATUS_OK, status);
+  EXPECT_EQ(SYNC_STATUS_OK, status1);
+  EXPECT_EQ(SYNC_STATUS_OK, status2);
 
   ASSERT_EQ(14u, log.size());
   int i = 0;
 
   // task1 takes "/foo/bar" first.
   EXPECT_EQ("task1: updating to /foo/bar", log[i++]);
-  EXPECT_EQ("task1: updated to /foo/bar", log[i++]);
 
   // task1 blocks task2. task2's update should be pending until task1 update.

[peria, 2014/06/18 06:58:00]

The following code expects different behaviors from this comment.
Which one is correct?

[tzik, 2014/06/19 04:04:56]

Updated the comment: "be pending" -> "not complete".
task2's update begins at this point, but does not complete until task1's
completion.

   EXPECT_EQ("task2: updating to /foo", log[i++]);
+  EXPECT_EQ("task1: updated to /foo/bar", log[i++]);
 
   // task1 releases "/foo/bar" and tries to take "/foo". Then, pending task2
   // takes "/foo" and blocks task1.
   EXPECT_EQ("task1: updating to /foo", log[i++]);
   EXPECT_EQ("task2: updated to /foo", log[i++]);
 
   // task2 releases "/foo".
   EXPECT_EQ("task2: updating to /foo/bar", log[i++]);
   EXPECT_EQ("task1: updated to /foo", log[i++]);
 
   // task1 releases "/foo".
   EXPECT_EQ("task1: updating to /hoge/fuga/piyo", log[i++]);
   EXPECT_EQ("task1: updated to /hoge/fuga/piyo", log[i++]);
   EXPECT_EQ("task2: updated to /foo/bar", log[i++]);
 
   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