Add function to CancelableTaskTracker and convert BootTimeLoader (take 2)

chrome/common/cancelable_task_tracker_unittest.cc

Index: chrome/common/cancelable_task_tracker_unittest.cc
diff --git a/chrome/common/cancelable_task_tracker_unittest.cc b/chrome/common/cancelable_task_tracker_unittest.cc
index 60315bcfc3293a7c91da3c3c999b1f55b8fff38a..c6a7a8583e0cc370deab7bcfd6160087a670045b 100644
--- a/chrome/common/cancelable_task_tracker_unittest.cc
+++ b/chrome/common/cancelable_task_tracker_unittest.cc
@@ -67,12 +67,14 @@ class CancelableTaskTrackerTest : public testing::Test {
   virtual void TearDown() {
     UnblockTaskThread();
 
-    // Create tracker on client thread.
+    // Destroy tracker on client thread.
     WaitableEvent tracker_destroyed(true, false);
     client_thread_runner_->PostTask(
         FROM_HERE,
         Bind(&CancelableTaskTrackerTest::DestroyTrackerOnClientThread,
              Unretained(this), &tracker_destroyed));
+
+    // This will also wait for any pending tasks on client thread.
     tracker_destroyed.Wait();
 
     client_thread_->Stop();
@@ -112,6 +114,13 @@ class CancelableTaskTrackerTest : public testing::Test {
                 &test_data_, event);
   }
 
+  Closure IncreaseTestDataIfNotCanceledAndSignalClosure(
+      const CancelableTaskTracker::IsCanceledCallback& is_canceled_cb,
+      WaitableEvent* event) {
+    return Bind(&CancelableTaskTrackerTest::IncreaseDataIfNotCanceledAndSignal,
+                &test_data_, is_canceled_cb, event);
+  }
+
   Closure DecreaseTestDataClosure(WaitableEvent* event) {
     return Bind(&CancelableTaskTrackerTest::DecreaseData,
                 Owned(new WaitableEventScoper(event)), &test_data_);
@@ -134,6 +143,16 @@ class CancelableTaskTrackerTest : public testing::Test {
       event->Signal();
   }
 
+  static void IncreaseDataIfNotCanceledAndSignal(
+      int* data,
+      const CancelableTaskTracker::IsCanceledCallback& is_canceled_cb,
+      WaitableEvent* event) {
+    if (!is_canceled_cb.Run())
+      (*data)++;
+    if (event)
+      event->Signal();
+  }
+
   static void DecreaseData(WaitableEventScoper* event_scoper, int* data) {
     (*data) -= 2;
   }
@@ -145,6 +164,7 @@ class CancelableTaskTrackerTest : public testing::Test {
 };
 
 #if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)) && GTEST_HAS_DEATH_TEST
+
 typedef CancelableTaskTrackerTest CancelableTaskTrackerDeathTest;
 
 TEST_F(CancelableTaskTrackerDeathTest, PostFromDifferentThread) {
@@ -325,4 +345,52 @@ TEST_F(CancelableTaskTrackerTest, TrackerDestructedAfterTask) {
   EXPECT_EQ(1, test_data_);
 }
 
+void CheckTrackedTaskIdOnSameThread_Test(CancelableTaskTrackerTest* test,
+                                         WaitableEvent* event) {
+  CancelableTaskTracker::IsCanceledCallback is_canceled_cb;
+  test->task_id_ = test->tracker_->NewTrackedTaskId(&is_canceled_cb);
+  ASSERT_NE(CancelableTaskTracker::kBadTaskId, test->task_id_);
+
+  EXPECT_FALSE(is_canceled_cb.Run());
+
+  test->tracker_->TryCancel(test->task_id_);
+  EXPECT_TRUE(is_canceled_cb.Run());
+
+  test->task_id_ = test->tracker_->NewTrackedTaskId(&is_canceled_cb);
+  EXPECT_FALSE(is_canceled_cb.Run());
+
+  // Destroy tracker will cancel all tasks.
+  test->tracker_.reset();
+  EXPECT_TRUE(is_canceled_cb.Run());
+
+  event->Signal();
+}
+
+TEST_F(CancelableTaskTrackerTest, CheckTrackedTaskIdOnSameThread) {
+  RunOnClientAndWait(&CheckTrackedTaskIdOnSameThread_Test);
+}
+
+void CheckTrackedTaskIdOnDifferentThread_Test(CancelableTaskTrackerTest* test,
+                                              WaitableEvent* event) {
+  CancelableTaskTracker::IsCanceledCallback is_canceled_cb;
+  test->task_id_ = test->tracker_->NewTrackedTaskId(&is_canceled_cb);
+  ASSERT_NE(CancelableTaskTracker::kBadTaskId, test->task_id_);
+
+  // Post task to task thread.
+  test->task_thread_runner_->PostTask(
+      FROM_HERE,
+      test->IncreaseTestDataIfNotCanceledAndSignalClosure(is_canceled_cb,
+                                                          event));
+  is_canceled_cb.Reset();  // So the one in task thread runner is the last ref,
+                           // and will be destroyed on task thread.
+
+  test->tracker_->TryCancel(test->task_id_);
+  test->UnblockTaskThread();
+}
+
+TEST_F(CancelableTaskTrackerTest, CheckTrackedTaskIdOnDifferentThread) {
+  RunOnClientAndWait(&CheckTrackedTaskIdOnDifferentThread_Test);
+  EXPECT_EQ(0, test_data_);
+}
+
 }  // namespace