| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
