Make SyncTaskManager's regular Task cancellable (like SyncTask)

chrome/browser/sync_file_system/sync_task_manager_unittest.cc

 // Copyright 2013 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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "chrome/browser/sync_file_system/sync_task_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace sync_file_system {
 
 namespace {
 
 void IncrementAndAssign(int* counter,
                         SyncStatusCode* status_out,
                         SyncStatusCode status) {
   ++(*counter);
   *status_out = status;
 }
 
+template <typename T>
+void IncrementAndAssignWithOwnedPointer(T* object,
+                                        int* counter,
+                                        SyncStatusCode* status_out,
+                                        SyncStatusCode status) {
+  ++(*counter);
+  *status_out = status;
+}
+
 class TaskManagerClient
     : public SyncTaskManager::Client,
       public base::SupportsWeakPtr<TaskManagerClient> {
  public:
   TaskManagerClient()
       : 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()));
@@ skipping 195 matching lines @@
         base::Bind(&IncrementAndAssign, &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, ScheduleAndCancelTask) {
+  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>()));
+    task_manager.Initialize(SYNC_STATUS_OK);
+    MultihopSyncTask* task = new MultihopSyncTask(
+        &task_started, &task_completed);
+    task_manager.ScheduleTask(
+        base::Bind(&MultihopSyncTask::Run, base::Unretained(task)),
+        base::Bind(&IncrementAndAssignWithOwnedPointer<MultihopSyncTask>,
+                   base::Owned(task), &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);
+}
+
 }  // namespace sync_file_system