Add function to CancelableTaskTracker and convert BootTimeLoader (take 2)

chrome/common/cancelable_task_tracker_unittest.cc

 // Copyright (c) 2011 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/common/cancelable_task_tracker.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 49 matching lines @@
 
     // Block server thread so we can prepare the test.
     task_thread_runner_->PostTask(
         FROM_HERE,
         Bind(&WaitableEvent::Wait, Unretained(&task_thread_start_event_)));
   }
 
   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();
     task_thread_->Stop();
   }
 
   void RunOnClientAndWait(
       void (*func)(CancelableTaskTrackerTest*, WaitableEvent*)) {
     WaitableEvent event(true, false);
     client_thread_runner_->PostTask(FROM_HERE,
@@ skipping 19 matching lines @@
 
   //////////////////////////////////////////////////////////////////////////////
   // Testing data and related functions
   int test_data_;  // Defaults to 0.
 
   Closure IncreaseTestDataAndSignalClosure(WaitableEvent* event) {
     return Bind(&CancelableTaskTrackerTest::IncreaseDataAndSignal,
                 &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_);
   }
 
  private:
   void CreateTrackerOnClientThread(WaitableEvent* event) {
     tracker_.reset(new CancelableTaskTracker());
     event->Signal();
   }
 
   void DestroyTrackerOnClientThread(WaitableEvent* event) {
     tracker_.reset();
     event->Signal();
   }
 
   static void IncreaseDataAndSignal(int* data, WaitableEvent* event) {
     (*data)++;
     if (event)
       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;
   }
 
   scoped_ptr<Thread> client_thread_;
   scoped_ptr<Thread> task_thread_;
 
   WaitableEvent task_thread_start_event_;
 };
 
 #if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)) && GTEST_HAS_DEATH_TEST
+
 typedef CancelableTaskTrackerTest CancelableTaskTrackerDeathTest;
 
 TEST_F(CancelableTaskTrackerDeathTest, PostFromDifferentThread) {
   // The default style "fast" does not support multi-threaded tests.
   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 
   EXPECT_DEATH(
       tracker_->PostTask(task_thread_runner_,
                          FROM_HERE,
                          DecreaseTestDataClosure(NULL)),
@@ skipping 160 matching lines @@
   // started yet (because this function is still running on client thread).
   // Now delete the tracker to cancel reply.
   test->tracker_.reset();
 }
 
 TEST_F(CancelableTaskTrackerTest, TrackerDestructedAfterTask) {
   RunOnClientAndWait(&TrackerDestructedAfterTask_Test);
   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