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