TaskScheduler: Add FlushForTesting().

base/task_scheduler/scheduler_worker_unittest.cc

 // Copyright 2016 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 "base/task_scheduler/scheduler_worker.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <vector>
@@ skipping 334 matching lines @@
                         TaskSchedulerWorkerTest,
                         ::testing::Values(1));
 INSTANTIATE_TEST_CASE_P(TwoTasksPerSequence,
                         TaskSchedulerWorkerTest,
                         ::testing::Values(2));
 
 namespace {
 
 class ControllableDetachDelegate : public SchedulerWorkerDefaultDelegate {
  public:
-  ControllableDetachDelegate()
-      : work_processed_(WaitableEvent::ResetPolicy::MANUAL,
+  ControllableDetachDelegate(TaskTracker* task_tracker)
+      : task_tracker_(task_tracker),
+        work_processed_(WaitableEvent::ResetPolicy::MANUAL,
                         WaitableEvent::InitialState::NOT_SIGNALED),
         detach_requested_(WaitableEvent::ResetPolicy::MANUAL,
-                          WaitableEvent::InitialState::NOT_SIGNALED) {}
+                          WaitableEvent::InitialState::NOT_SIGNALED) {
+    EXPECT_TRUE(task_tracker_);
+  }
 
   ~ControllableDetachDelegate() override = default;
 
   // SchedulerWorker::Delegate:
   MOCK_METHOD2(OnMainEntry,
                void(SchedulerWorker* worker, const TimeDelta& detach_duration));
 
   scoped_refptr<Sequence> GetWork(SchedulerWorker* worker)
       override {
     // Sends one item of work to signal |work_processed_|. On subsequent calls,
     // sends nullptr to indicate there's no more work to be done.
     if (work_requested_)
       return nullptr;
 
     work_requested_ = true;
     scoped_refptr<Sequence> sequence(new Sequence);
     std::unique_ptr<Task> task(new Task(
         FROM_HERE, Bind(&WaitableEvent::Signal, Unretained(&work_processed_)),
         TaskTraits(), TimeDelta()));
+    EXPECT_TRUE(task_tracker_->WillPostTask(task.get()));
     sequence->PushTask(std::move(task));
     return sequence;
   }
 
   void DidRunTask(const Task* task, const TimeDelta& task_latency) override {}
 
   bool CanDetach(SchedulerWorker* worker) override {
     detach_requested_.Signal();
     return can_detach_;
   }
 
   void WaitForWorkToRun() {
     work_processed_.Wait();
   }
 
   void WaitForDetachRequest() {
     detach_requested_.Wait();
   }
 
   void ResetState() {
     work_requested_ = false;
     work_processed_.Reset();
     detach_requested_.Reset();
   }
 
   void set_can_detach(bool can_detach) { can_detach_ = can_detach; }
 
  private:
+  TaskTracker* const task_tracker_;
   bool work_requested_ = false;
   bool can_detach_ = false;
   WaitableEvent work_processed_;
   WaitableEvent detach_requested_;
 
   DISALLOW_COPY_AND_ASSIGN(ControllableDetachDelegate);
 };
 
 }  // namespace
 
 TEST(TaskSchedulerWorkerTest, WorkerDetaches) {
   TaskTracker task_tracker;
   // Will be owned by SchedulerWorker.
   ControllableDetachDelegate* delegate =
-      new StrictMock<ControllableDetachDelegate>;
+      new StrictMock<ControllableDetachDelegate>(&task_tracker);
   delegate->set_can_detach(true);
   EXPECT_CALL(*delegate, OnMainEntry(_, TimeDelta::Max()));
   std::unique_ptr<SchedulerWorker> worker =
       SchedulerWorker::Create(
           ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker,
           SchedulerWorker::InitialState::ALIVE);
   worker->WakeUp();
   delegate->WaitForWorkToRun();
   Mock::VerifyAndClear(delegate);
   delegate->WaitForDetachRequest();
   // Sleep to give a chance for the detach to happen. A yield is too short.
   PlatformThread::Sleep(TimeDelta::FromMilliseconds(50));
   ASSERT_FALSE(worker->ThreadAliveForTesting());
 }
 
 TEST(TaskSchedulerWorkerTest, WorkerDetachesAndWakes) {
   TaskTracker task_tracker;
   // Will be owned by SchedulerWorker.
   ControllableDetachDelegate* delegate =
-      new StrictMock<ControllableDetachDelegate>;
+      new StrictMock<ControllableDetachDelegate>(&task_tracker);
   delegate->set_can_detach(true);
   EXPECT_CALL(*delegate, OnMainEntry(_, TimeDelta::Max()));
   std::unique_ptr<SchedulerWorker> worker =
       SchedulerWorker::Create(
           ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker,
           SchedulerWorker::InitialState::ALIVE);
   worker->WakeUp();
   delegate->WaitForWorkToRun();
   Mock::VerifyAndClear(delegate);
   delegate->WaitForDetachRequest();
@@ skipping 12 matching lines @@
   delegate->WaitForDetachRequest();
   PlatformThread::Sleep(TimeDelta::FromMilliseconds(50));
   ASSERT_TRUE(worker->ThreadAliveForTesting());
   worker->JoinForTesting();
 }
 
 TEST(TaskSchedulerWorkerTest, CreateDetached) {
   TaskTracker task_tracker;
   // Will be owned by SchedulerWorker.
   ControllableDetachDelegate* delegate =
-      new StrictMock<ControllableDetachDelegate>;
+      new StrictMock<ControllableDetachDelegate>(&task_tracker);
   std::unique_ptr<SchedulerWorker> worker =
       SchedulerWorker::Create(
           ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker,
           SchedulerWorker::InitialState::DETACHED);
   ASSERT_FALSE(worker->ThreadAliveForTesting());
   EXPECT_CALL(*delegate, OnMainEntry(worker.get(), TimeDelta::Max()));
   worker->WakeUp();
   delegate->WaitForWorkToRun();
   Mock::VerifyAndClear(delegate);
   delegate->WaitForDetachRequest();
@@ skipping 100 matching lines @@
   // OnMainEntry() and GetWork() are called.
   worker->WakeUp();
   delegate_raw->WaitForPriorityVerifiedInGetWork();
 
   worker->JoinForTesting();
 }
 
 }  // namespace
 }  // namespace internal
 }  // namespace base