[SyncFS] Refine SyncProcessRunner's throttling algorithm for parallel task support

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 <deque>
+
 #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) {}
@@ skipping 64 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(FakeTimerHelper);
 };
 
 class FakeSyncProcessRunner : public SyncProcessRunner {
  public:
   FakeSyncProcessRunner(SyncProcessRunner::Client* client,
                         scoped_ptr<TimerHelper> timer_helper,
                         int max_parallel_task)
       : SyncProcessRunner("FakeSyncProcess",
                           client, timer_helper.Pass(),
-                          max_parallel_task) {
+                          max_parallel_task),
+        max_parallel_task_(max_parallel_task) {
   }
 
   virtual void StartSync(const SyncStatusCallback& callback) OVERRIDE {
-    EXPECT_TRUE(running_task_.is_null());
-    running_task_ = callback;
+    EXPECT_LT(running_tasks_.size(), max_parallel_task_);
+    running_tasks_.push_back(callback);
   }
 
   virtual ~FakeSyncProcessRunner() {
   }
 
   void UpdateChanges(int num_changes) {
     OnChangesUpdated(num_changes);
   }
 
   void CompleteTask(SyncStatusCode status) {
-    ASSERT_FALSE(running_task_.is_null());
-    SyncStatusCallback task = running_task_;
-    running_task_.Reset();
+    ASSERT_FALSE(running_tasks_.empty());
+    SyncStatusCallback task = running_tasks_.front();
+    running_tasks_.pop_front();
     task.Run(status);
   }
 
   bool HasRunningTask() const {
-    return !running_task_.is_null();
+    return !running_tasks_.empty();
   }
 
  private:
-  SyncStatusCallback running_task_;
+  int64 max_parallel_task_;
+  std::deque<SyncStatusCallback> running_tasks_;
 
   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),
       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.
   fake_runner.UpdateChanges(100);
   EXPECT_TRUE(fake_timer->IsRunning());
   EXPECT_EQ(SyncProcessRunner::kSyncDelayFastInMilliseconds,
             fake_timer->GetCurrentDelay());
 
   // When the time has come, the timer should fire the scheduled task.
   fake_timer->AdvanceToScheduledTime();
-  EXPECT_FALSE(fake_timer->IsRunning());
+  // EXPECT_FALSE(fake_timer->IsRunning());
   EXPECT_TRUE(fake_runner.HasRunningTask());
 
   // Successful completion of the task fires next synchronization task.
   fake_runner.CompleteTask(SYNC_STATUS_OK);
   EXPECT_TRUE(fake_timer->IsRunning());
   EXPECT_FALSE(fake_runner.HasRunningTask());
   EXPECT_EQ(SyncProcessRunner::kSyncDelayFastInMilliseconds,
             fake_timer->GetCurrentDelay());
 
   // Turn |service_state| to TEMPORARY_UNAVAILABLE and let the task fail.
@@ skipping 20 matching lines @@
 
   // There's no item to sync anymore, SyncProcessRunner should schedules the
   // next with the longest delay.
   fake_runner.UpdateChanges(0);
   fake_timer->AdvanceToScheduledTime();
   fake_runner.CompleteTask(SYNC_STATUS_OK);
   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),
+      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,
+            fake_timer->GetCurrentDelay());
+
+  // Even after a task starts running, SyncProcessRunner should schedule next
+  // task until the number of running task reachs the limit.
+  fake_timer->AdvanceToScheduledTime();
+  EXPECT_TRUE(fake_timer->IsRunning());
+  EXPECT_TRUE(fake_runner.HasRunningTask());
+  EXPECT_EQ(SyncProcessRunner::kSyncDelayFastInMilliseconds,
+            fake_timer->GetCurrentDelay());
+
+  // After the second task starts running, SyncProcessRunner should stop
+  // scheduling a task.
+  fake_timer->AdvanceToScheduledTime();
+  EXPECT_FALSE(fake_timer->IsRunning());
+  EXPECT_TRUE(fake_runner.HasRunningTask());
+
+  fake_runner.CompleteTask(SYNC_STATUS_OK);
+  EXPECT_TRUE(fake_timer->IsRunning());
+  EXPECT_TRUE(fake_runner.HasRunningTask());
+  fake_runner.CompleteTask(SYNC_STATUS_OK);
+  EXPECT_TRUE(fake_timer->IsRunning());
+  EXPECT_FALSE(fake_runner.HasRunningTask());
+
+  // Turn |service_state| to TEMPORARY_UNAVAILABLE and let the task fail.
+  // |fake_runner| should schedule following tasks with longer delay.
+  fake_timer->AdvanceToScheduledTime();
+  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());
+
+  // Consecutive error reports shouldn't extend delay immediately.
+  fake_runner.CompleteTask(SYNC_STATUS_FAILED);
+  EXPECT_EQ(SyncProcessRunner::kSyncDelaySlowInMilliseconds,
+            fake_timer->GetCurrentDelay());
+
+  // The next task will run after throttle period is over.
+  // And its failure should extend the throttle period by twice.
+  fake_timer->AdvanceToScheduledTime();
+  EXPECT_EQ(SyncProcessRunner::kSyncDelaySlowInMilliseconds,
+            fake_timer->GetCurrentDelay());
+  fake_runner.CompleteTask(SYNC_STATUS_FAILED);
+  EXPECT_EQ(2 * SyncProcessRunner::kSyncDelaySlowInMilliseconds,
+            fake_timer->GetCurrentDelay());
+
+  // Next successful task should clear the throttling.
+  fake_timer->AdvanceToScheduledTime();
+  fake_client.set_service_state(SYNC_SERVICE_RUNNING);
+  fake_runner.CompleteTask(SYNC_STATUS_OK);
+  EXPECT_EQ(SyncProcessRunner::kSyncDelayFastInMilliseconds,
+            fake_timer->GetCurrentDelay());
+
+  // 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());

[nhiroki, 2014/07/14 02:27:06]

How about testing DelayMax case, that is, AUTHENTICATION_REQUIRED or DISABLED?

[tzik, 2014/07/14 04:52:04]

Done.

+}
+
 }  // namespace sync_file_system