base/task/cancelable_task_tracker_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/task/cancelable_task_tracker.h"
   6
   7 #include <cstddef>
   8 #include <deque>
   9
  10 #include "base/bind.h"
  11 #include "base/bind_helpers.h"
  12 #include "base/location.h"
  13 #include "base/logging.h"
  14 #include "base/memory/ref_counted.h"
  15 #include "base/memory/weak_ptr.h"
  16 #include "base/run_loop.h"
  17 #include "base/single_thread_task_runner.h"
  18 #include "base/test/test_simple_task_runner.h"
  19 #include "base/threading/thread.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21
  22 namespace base {
  23
  24 namespace {
  25
  26 class CancelableTaskTrackerTest : public testing::Test {
  27  protected:
  28   ~CancelableTaskTrackerTest() override { RunCurrentLoopUntilIdle(); }
  29
  30   void RunCurrentLoopUntilIdle() {
  31     RunLoop run_loop;
  32     run_loop.RunUntilIdle();
  33   }
  34
  35   CancelableTaskTracker task_tracker_;
  36
  37  private:
  38   // Needed by CancelableTaskTracker methods.
  39   MessageLoop message_loop_;
  40 };
  41
  42 void AddFailureAt(const tracked_objects::Location& location) {
  43   ADD_FAILURE_AT(location.file_name(), location.line_number());
  44 }
  45
  46 // Returns a closure that fails if run.
  47 Closure MakeExpectedNotRunClosure(const tracked_objects::Location& location) {
  48   return Bind(&AddFailureAt, location);
  49 }
  50
  51 // A helper class for MakeExpectedRunClosure() that fails if it is
  52 // destroyed without Run() having been called.  This class may be used
  53 // from multiple threads as long as Run() is called at most once
  54 // before destruction.
  55 class RunChecker {
  56  public:
  57   explicit RunChecker(const tracked_objects::Location& location)
  58       : location_(location), called_(false) {}
  59
  60   ~RunChecker() {
  61     if (!called_) {
  62       ADD_FAILURE_AT(location_.file_name(), location_.line_number());
  63     }
  64   }
  65
  66   void Run() { called_ = true; }
  67
  68  private:
  69   tracked_objects::Location location_;
  70   bool called_;
  71 };
  72
  73 // Returns a closure that fails on destruction if it hasn't been run.
  74 Closure MakeExpectedRunClosure(const tracked_objects::Location& location) {
  75   return Bind(&RunChecker::Run, Owned(new RunChecker(location)));
  76 }
  77
  78 }  // namespace
  79
  80 // With the task tracker, post a task, a task with a reply, and get a
  81 // new task id without canceling any of them.  The tasks and the reply
  82 // should run and the "is canceled" callback should return false.
  83 TEST_F(CancelableTaskTrackerTest, NoCancel) {
  84   Thread worker_thread("worker thread");
  85   ASSERT_TRUE(worker_thread.Start());
  86
  87   ignore_result(task_tracker_.PostTask(worker_thread.task_runner().get(),
  88                                        FROM_HERE,
  89                                        MakeExpectedRunClosure(FROM_HERE)));
  90
  91   ignore_result(task_tracker_.PostTaskAndReply(
  92       worker_thread.task_runner().get(), FROM_HERE,
  93       MakeExpectedRunClosure(FROM_HERE), MakeExpectedRunClosure(FROM_HERE)));
  94
  95   CancelableTaskTracker::IsCanceledCallback is_canceled;
  96   ignore_result(task_tracker_.NewTrackedTaskId(&is_canceled));
  97
  98   worker_thread.Stop();
  99
 100   RunCurrentLoopUntilIdle();
 101
 102   EXPECT_FALSE(is_canceled.Run());
 103 }
 104
 105 // Post a task with the task tracker but cancel it before running the
 106 // task runner.  The task should not run.
 107 TEST_F(CancelableTaskTrackerTest, CancelPostedTask) {
 108   scoped_refptr<TestSimpleTaskRunner> test_task_runner(
 109       new TestSimpleTaskRunner());
 110
 111   CancelableTaskTracker::TaskId task_id = task_tracker_.PostTask(
 112       test_task_runner.get(), FROM_HERE, MakeExpectedNotRunClosure(FROM_HERE));
 113   EXPECT_NE(CancelableTaskTracker::kBadTaskId, task_id);
 114
 115   EXPECT_EQ(1U, test_task_runner->GetPendingTasks().size());
 116
 117   task_tracker_.TryCancel(task_id);
 118
 119   test_task_runner->RunUntilIdle();
 120 }
 121
 122 // Post a task with reply with the task tracker and cancel it before
 123 // running the task runner.  Neither the task nor the reply should
 124 // run.
 125 TEST_F(CancelableTaskTrackerTest, CancelPostedTaskAndReply) {
 126   scoped_refptr<TestSimpleTaskRunner> test_task_runner(
 127       new TestSimpleTaskRunner());
 128
 129   CancelableTaskTracker::TaskId task_id =
 130       task_tracker_.PostTaskAndReply(test_task_runner.get(),
 131                                      FROM_HERE,
 132                                      MakeExpectedNotRunClosure(FROM_HERE),
 133                                      MakeExpectedNotRunClosure(FROM_HERE));
 134   EXPECT_NE(CancelableTaskTracker::kBadTaskId, task_id);
 135
 136   task_tracker_.TryCancel(task_id);
 137
 138   test_task_runner->RunUntilIdle();
 139 }
 140
 141 // Post a task with reply with the task tracker and cancel it after
 142 // running the task runner but before running the current message
 143 // loop.  The task should run but the reply should not.
 144 TEST_F(CancelableTaskTrackerTest, CancelReply) {
 145   scoped_refptr<TestSimpleTaskRunner> test_task_runner(
 146       new TestSimpleTaskRunner());
 147
 148   CancelableTaskTracker::TaskId task_id =
 149       task_tracker_.PostTaskAndReply(test_task_runner.get(),
 150                                      FROM_HERE,
 151                                      MakeExpectedRunClosure(FROM_HERE),
 152                                      MakeExpectedNotRunClosure(FROM_HERE));
 153   EXPECT_NE(CancelableTaskTracker::kBadTaskId, task_id);
 154
 155   test_task_runner->RunUntilIdle();
 156
 157   task_tracker_.TryCancel(task_id);
 158 }
 159
 160 // Post a task with reply with the task tracker on a worker thread and
 161 // cancel it before running the current message loop.  The task should
 162 // run but the reply should not.
 163 TEST_F(CancelableTaskTrackerTest, CancelReplyDifferentThread) {
 164   Thread worker_thread("worker thread");
 165   ASSERT_TRUE(worker_thread.Start());
 166
 167   CancelableTaskTracker::TaskId task_id = task_tracker_.PostTaskAndReply(
 168       worker_thread.task_runner().get(), FROM_HERE, Bind(&DoNothing),
 169       MakeExpectedNotRunClosure(FROM_HERE));
 170   EXPECT_NE(CancelableTaskTracker::kBadTaskId, task_id);
 171
 172   task_tracker_.TryCancel(task_id);
 173
 174   worker_thread.Stop();
 175 }
 176
 177 void ExpectIsCanceled(
 178     const CancelableTaskTracker::IsCanceledCallback& is_canceled,
 179     bool expected_is_canceled) {
 180   EXPECT_EQ(expected_is_canceled, is_canceled.Run());
 181 }
 182
 183 // Create a new task ID and check its status on a separate thread
 184 // before and after canceling.  The is-canceled callback should be
 185 // thread-safe (i.e., nothing should blow up).
 186 TEST_F(CancelableTaskTrackerTest, NewTrackedTaskIdDifferentThread) {
 187   CancelableTaskTracker::IsCanceledCallback is_canceled;
 188   CancelableTaskTracker::TaskId task_id =
 189       task_tracker_.NewTrackedTaskId(&is_canceled);
 190
 191   EXPECT_FALSE(is_canceled.Run());
 192
 193   Thread other_thread("other thread");
 194   ASSERT_TRUE(other_thread.Start());
 195   other_thread.task_runner()->PostTask(
 196       FROM_HERE, Bind(&ExpectIsCanceled, is_canceled, false));
 197   other_thread.Stop();
 198
 199   task_tracker_.TryCancel(task_id);
 200
 201   ASSERT_TRUE(other_thread.Start());
 202   other_thread.task_runner()->PostTask(
 203       FROM_HERE, Bind(&ExpectIsCanceled, is_canceled, true));
 204   other_thread.Stop();
 205 }
 206
 207 // With the task tracker, post a task, a task with a reply, get a new
 208 // task id, and then cancel all of them.  None of the tasks nor the
 209 // reply should run and the "is canceled" callback should return
 210 // true.
 211 TEST_F(CancelableTaskTrackerTest, CancelAll) {
 212   scoped_refptr<TestSimpleTaskRunner> test_task_runner(
 213       new TestSimpleTaskRunner());
 214
 215   ignore_result(task_tracker_.PostTask(
 216       test_task_runner.get(), FROM_HERE, MakeExpectedNotRunClosure(FROM_HERE)));
 217
 218   ignore_result(
 219       task_tracker_.PostTaskAndReply(test_task_runner.get(),
 220                                      FROM_HERE,
 221                                      MakeExpectedNotRunClosure(FROM_HERE),
 222                                      MakeExpectedNotRunClosure(FROM_HERE)));
 223
 224   CancelableTaskTracker::IsCanceledCallback is_canceled;
 225   ignore_result(task_tracker_.NewTrackedTaskId(&is_canceled));
 226
 227   task_tracker_.TryCancelAll();
 228
 229   test_task_runner->RunUntilIdle();
 230
 231   RunCurrentLoopUntilIdle();
 232
 233   EXPECT_TRUE(is_canceled.Run());
 234 }
 235
 236 // With the task tracker, post a task, a task with a reply, get a new
 237 // task id, and then cancel all of them.  None of the tasks nor the
 238 // reply should run and the "is canceled" callback should return
 239 // true.
 240 TEST_F(CancelableTaskTrackerTest, DestructionCancelsAll) {
 241   scoped_refptr<TestSimpleTaskRunner> test_task_runner(
 242       new TestSimpleTaskRunner());
 243
 244   CancelableTaskTracker::IsCanceledCallback is_canceled;
 245
 246   {
 247     // Create another task tracker with a smaller scope.
 248     CancelableTaskTracker task_tracker;
 249
 250     ignore_result(task_tracker.PostTask(test_task_runner.get(),
 251                                         FROM_HERE,
 252                                         MakeExpectedNotRunClosure(FROM_HERE)));
 253
 254     ignore_result(
 255         task_tracker.PostTaskAndReply(test_task_runner.get(),
 256                                       FROM_HERE,
 257                                       MakeExpectedNotRunClosure(FROM_HERE),
 258                                       MakeExpectedNotRunClosure(FROM_HERE)));
 259
 260     ignore_result(task_tracker_.NewTrackedTaskId(&is_canceled));
 261   }
 262
 263   test_task_runner->RunUntilIdle();
 264
 265   RunCurrentLoopUntilIdle();
 266
 267   EXPECT_FALSE(is_canceled.Run());
 268 }
 269
 270 // Post a task and cancel it.  HasTrackedTasks() should return true
 271 // from when the task is posted until the (do-nothing) reply task is
 272 // flushed.
 273 TEST_F(CancelableTaskTrackerTest, HasTrackedTasksPost) {
 274   scoped_refptr<TestSimpleTaskRunner> test_task_runner(
 275       new TestSimpleTaskRunner());
 276
 277   EXPECT_FALSE(task_tracker_.HasTrackedTasks());
 278
 279   ignore_result(task_tracker_.PostTask(
 280       test_task_runner.get(), FROM_HERE, MakeExpectedNotRunClosure(FROM_HERE)));
 281
 282   task_tracker_.TryCancelAll();
 283
 284   test_task_runner->RunUntilIdle();
 285
 286   EXPECT_TRUE(task_tracker_.HasTrackedTasks());
 287
 288   RunCurrentLoopUntilIdle();
 289
 290   EXPECT_FALSE(task_tracker_.HasTrackedTasks());
 291 }
 292
 293 // Post a task with a reply and cancel it.  HasTrackedTasks() should
 294 // return true from when the task is posted until it is canceled.
 295 TEST_F(CancelableTaskTrackerTest, HasTrackedTasksPostWithReply) {
 296   scoped_refptr<TestSimpleTaskRunner> test_task_runner(
 297       new TestSimpleTaskRunner());
 298
 299   EXPECT_FALSE(task_tracker_.HasTrackedTasks());
 300
 301   ignore_result(
 302       task_tracker_.PostTaskAndReply(test_task_runner.get(),
 303                                      FROM_HERE,
 304                                      MakeExpectedNotRunClosure(FROM_HERE),
 305                                      MakeExpectedNotRunClosure(FROM_HERE)));
 306
 307   task_tracker_.TryCancelAll();
 308
 309   test_task_runner->RunUntilIdle();
 310
 311   EXPECT_TRUE(task_tracker_.HasTrackedTasks());
 312
 313   RunCurrentLoopUntilIdle();
 314
 315   EXPECT_FALSE(task_tracker_.HasTrackedTasks());
 316 }
 317
 318 // Create a new tracked task ID.  HasTrackedTasks() should return true
 319 // until the IsCanceledCallback is destroyed.
 320 TEST_F(CancelableTaskTrackerTest, HasTrackedTasksIsCancelled) {
 321   EXPECT_FALSE(task_tracker_.HasTrackedTasks());
 322
 323   CancelableTaskTracker::IsCanceledCallback is_canceled;
 324   ignore_result(task_tracker_.NewTrackedTaskId(&is_canceled));
 325
 326   task_tracker_.TryCancelAll();
 327
 328   EXPECT_TRUE(task_tracker_.HasTrackedTasks());
 329
 330   is_canceled.Reset();
 331
 332   EXPECT_FALSE(task_tracker_.HasTrackedTasks());
 333 }
 334
 335 // The death tests below make sure that calling task tracker member
 336 // functions from a thread different from its owner thread DCHECKs in
 337 // debug mode.
 338
 339 class CancelableTaskTrackerDeathTest : public CancelableTaskTrackerTest {
 340  protected:
 341   CancelableTaskTrackerDeathTest() {
 342     // The default style "fast" does not support multi-threaded tests.
 343     ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 344   }
 345 };
 346
 347 // Duplicated from base/threading/thread_checker.h so that we can be
 348 // good citizens there and undef the macro.
 349 #if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
 350 #define ENABLE_THREAD_CHECKER 1
 351 #else
 352 #define ENABLE_THREAD_CHECKER 0
 353 #endif
 354
 355 // Runs |fn| with |task_tracker|, expecting it to crash in debug mode.
 356 void MaybeRunDeadlyTaskTrackerMemberFunction(
 357     CancelableTaskTracker* task_tracker,
 358     const Callback<void(CancelableTaskTracker*)>& fn) {
 359 // CancelableTask uses DCHECKs with its ThreadChecker (itself only
 360 // enabled in debug mode).
 361 #if ENABLE_THREAD_CHECKER
 362   EXPECT_DEATH_IF_SUPPORTED(fn.Run(task_tracker), "");
 363 #endif
 364 }
 365
 366 void PostDoNothingTask(CancelableTaskTracker* task_tracker) {
 367   ignore_result(task_tracker->PostTask(
 368       scoped_refptr<TestSimpleTaskRunner>(new TestSimpleTaskRunner()).get(),
 369       FROM_HERE,
 370       Bind(&DoNothing)));
 371 }
 372
 373 TEST_F(CancelableTaskTrackerDeathTest, PostFromDifferentThread) {
 374   Thread bad_thread("bad thread");
 375   ASSERT_TRUE(bad_thread.Start());
 376
 377   bad_thread.task_runner()->PostTask(
 378       FROM_HERE, Bind(&MaybeRunDeadlyTaskTrackerMemberFunction,
 379                       Unretained(&task_tracker_), Bind(&PostDoNothingTask)));
 380 }
 381
 382 void TryCancel(CancelableTaskTracker::TaskId task_id,
 383                CancelableTaskTracker* task_tracker) {
 384   task_tracker->TryCancel(task_id);
 385 }
 386
 387 TEST_F(CancelableTaskTrackerDeathTest, CancelOnDifferentThread) {
 388   scoped_refptr<TestSimpleTaskRunner> test_task_runner(
 389       new TestSimpleTaskRunner());
 390
 391   Thread bad_thread("bad thread");
 392   ASSERT_TRUE(bad_thread.Start());
 393
 394   CancelableTaskTracker::TaskId task_id = task_tracker_.PostTask(
 395       test_task_runner.get(), FROM_HERE, Bind(&DoNothing));
 396   EXPECT_NE(CancelableTaskTracker::kBadTaskId, task_id);
 397
 398   bad_thread.task_runner()->PostTask(
 399       FROM_HERE, Bind(&MaybeRunDeadlyTaskTrackerMemberFunction,
 400                       Unretained(&task_tracker_), Bind(&TryCancel, task_id)));
 401
 402   test_task_runner->RunUntilIdle();
 403 }
 404
 405 TEST_F(CancelableTaskTrackerDeathTest, CancelAllOnDifferentThread) {
 406   scoped_refptr<TestSimpleTaskRunner> test_task_runner(
 407       new TestSimpleTaskRunner());
 408
 409   Thread bad_thread("bad thread");
 410   ASSERT_TRUE(bad_thread.Start());
 411
 412   CancelableTaskTracker::TaskId task_id = task_tracker_.PostTask(
 413       test_task_runner.get(), FROM_HERE, Bind(&DoNothing));
 414   EXPECT_NE(CancelableTaskTracker::kBadTaskId, task_id);
 415
 416   bad_thread.task_runner()->PostTask(
 417       FROM_HERE,
 418       Bind(&MaybeRunDeadlyTaskTrackerMemberFunction, Unretained(&task_tracker_),
 419            Bind(&CancelableTaskTracker::TryCancelAll)));
 420
 421   test_task_runner->RunUntilIdle();
 422 }
 423
 424 }  // namespace base