TaskScheduler: Record TaskScheduler.NumTasksBeforeDetach.* from OnDetach().

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 23 matching lines @@
 namespace internal {
 namespace {
 
 const size_t kNumSequencesPerTest = 150;
 
 class SchedulerWorkerDefaultDelegate : public SchedulerWorker::Delegate {
  public:
   SchedulerWorkerDefaultDelegate() = default;
 
   // SchedulerWorker::Delegate:
-  void OnMainEntry(SchedulerWorker* worker,
-                   const TimeDelta& detach_duration) override {}
+  void OnMainEntry(SchedulerWorker* worker) override {}
   scoped_refptr<Sequence> GetWork(SchedulerWorker* worker) override {
     return nullptr;
   }
   void DidRunTaskWithPriority(TaskPriority task_priority,
                               const TimeDelta& task_latency) override {
     ADD_FAILURE() << "Unexpected call to DidRunTaskWithPriority()";
   }
   void ReEnqueueSequence(scoped_refptr<Sequence> sequence) override {
     ADD_FAILURE() << "Unexpected call to ReEnqueueSequence()";
   }
   TimeDelta GetSleepTimeout() override { return TimeDelta::Max(); }
   bool CanDetach(SchedulerWorker* worker) override { return false; }
+  void OnDetach() override { ADD_FAILURE() << "Unexpected call to OnDetach()"; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SchedulerWorkerDefaultDelegate);
 };
 
 // The test parameter is the number of Tasks per Sequence returned by GetWork().
 class TaskSchedulerWorkerTest : public testing::TestWithParam<size_t> {
  protected:
   TaskSchedulerWorkerTest()
       : main_entry_called_(WaitableEvent::ResetPolicy::MANUAL,
@@ skipping 56 matching lines @@
   class TestSchedulerWorkerDelegate : public SchedulerWorkerDefaultDelegate {
    public:
     TestSchedulerWorkerDelegate(TaskSchedulerWorkerTest* outer)
         : outer_(outer) {}
 
     ~TestSchedulerWorkerDelegate() override {
       EXPECT_FALSE(IsCallToDidRunTaskWithPriorityExpected());
     }
 
     // SchedulerWorker::Delegate:
-    void OnMainEntry(SchedulerWorker* worker,
-                     const TimeDelta& detach_duration) override {
+    void OnMainEntry(SchedulerWorker* worker) override {
       outer_->worker_set_.Wait();
       EXPECT_EQ(outer_->worker_.get(), worker);
       EXPECT_FALSE(IsCallToDidRunTaskWithPriorityExpected());
 
       // Without synchronization, OnMainEntry() could be called twice without
       // generating an error.
       AutoSchedulerLock auto_lock(outer_->lock_);
       EXPECT_FALSE(outer_->main_entry_called_.IsSignaled());
       outer_->main_entry_called_.Signal();
     }
@@ skipping 210 matching lines @@
 
 namespace {
 
 class ControllableDetachDelegate : public SchedulerWorkerDefaultDelegate {
  public:
   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),
+        detached_(WaitableEvent::ResetPolicy::MANUAL,
+                  WaitableEvent::InitialState::NOT_SIGNALED) {
     EXPECT_TRUE(task_tracker_);
   }
 
   ~ControllableDetachDelegate() override = default;
 
   // SchedulerWorker::Delegate:
-  MOCK_METHOD2(OnMainEntry,
-               void(SchedulerWorker* worker, const TimeDelta& detach_duration));
+  MOCK_METHOD1(OnMainEntry, void(SchedulerWorker* worker));
 
   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 DidRunTaskWithPriority(TaskPriority task,
                               const TimeDelta& task_latency) override {}
 
   bool CanDetach(SchedulerWorker* worker) override {
     detach_requested_.Signal();
     return can_detach_;
   }
 
+  void OnDetach() override {
+    EXPECT_TRUE(can_detach_);
+    EXPECT_TRUE(detach_requested_.IsSignaled());
+    detached_.Signal();
+  }
+
   void WaitForWorkToRun() {
     work_processed_.Wait();
   }
 
   void WaitForDetachRequest() {
     detach_requested_.Wait();
   }
 
+  void WaitForDetach() { detached_.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_;
+  WaitableEvent detached_;
 
   DISALLOW_COPY_AND_ASSIGN(ControllableDetachDelegate);
 };
 
 }  // namespace
 
 TEST(TaskSchedulerWorkerTest, WorkerDetaches) {
   TaskTracker task_tracker;
   // Will be owned by SchedulerWorker.
   ControllableDetachDelegate* delegate =
       new StrictMock<ControllableDetachDelegate>(&task_tracker);
   delegate->set_can_detach(true);
-  EXPECT_CALL(*delegate, OnMainEntry(_, TimeDelta::Max()));
+  EXPECT_CALL(*delegate, OnMainEntry(_));
   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));
+  delegate->WaitForDetach();
   ASSERT_FALSE(worker->ThreadAliveForTesting());
 }
 
 TEST(TaskSchedulerWorkerTest, WorkerDetachesAndWakes) {
   TaskTracker task_tracker;
   // Will be owned by SchedulerWorker.
   ControllableDetachDelegate* delegate =
       new StrictMock<ControllableDetachDelegate>(&task_tracker);
   delegate->set_can_detach(true);
-  EXPECT_CALL(*delegate, OnMainEntry(_, TimeDelta::Max()));
+  EXPECT_CALL(*delegate, OnMainEntry(_));
   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));
+  delegate->WaitForDetach();
   ASSERT_FALSE(worker->ThreadAliveForTesting());
 
   delegate->ResetState();
   delegate->set_can_detach(false);
-  // When SchedulerWorker recreates its thread, expect OnMainEntry() to be
-  // called with a detach duration which is not TimeDelta::Max().
-  EXPECT_CALL(*delegate, OnMainEntry(worker.get(), Ne(TimeDelta::Max())));
+  // Expect OnMainEntry() to be called when SchedulerWorker recreates its
+  // thread.
+  EXPECT_CALL(*delegate, OnMainEntry(worker.get()));
   worker->WakeUp();
   delegate->WaitForWorkToRun();
   Mock::VerifyAndClear(delegate);
   delegate->WaitForDetachRequest();
-  PlatformThread::Sleep(TimeDelta::FromMilliseconds(50));
+  delegate->WaitForDetach();
   ASSERT_TRUE(worker->ThreadAliveForTesting());
   worker->JoinForTesting();
 }
 
 TEST(TaskSchedulerWorkerTest, CreateDetached) {
   TaskTracker task_tracker;
   // Will be owned by SchedulerWorker.
   ControllableDetachDelegate* delegate =
       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()));
+  EXPECT_CALL(*delegate, OnMainEntry(worker.get()));
   worker->WakeUp();
   delegate->WaitForWorkToRun();
   Mock::VerifyAndClear(delegate);
   delegate->WaitForDetachRequest();
   ASSERT_TRUE(worker->ThreadAliveForTesting());
   worker->JoinForTesting();
 }
 
 namespace {
 
 class ExpectThreadPriorityDelegate : public SchedulerWorkerDefaultDelegate {
  public:
   ExpectThreadPriorityDelegate()
       : priority_verified_in_get_work_event_(
             WaitableEvent::ResetPolicy::AUTOMATIC,
             WaitableEvent::InitialState::NOT_SIGNALED),
         expected_thread_priority_(ThreadPriority::BACKGROUND) {}
 
   void SetExpectedThreadPriority(ThreadPriority expected_thread_priority) {
     expected_thread_priority_ = expected_thread_priority;
   }
 
   void WaitForPriorityVerifiedInGetWork() {
     priority_verified_in_get_work_event_.Wait();
   }
 
   // SchedulerWorker::Delegate:
-  void OnMainEntry(SchedulerWorker* worker,
-                   const TimeDelta& detach_duration) override {
-    VerifyThreadPriority();
-  }
+  void OnMainEntry(SchedulerWorker* worker) override { VerifyThreadPriority(); }
   scoped_refptr<Sequence> GetWork(SchedulerWorker* worker) override {
     VerifyThreadPriority();
     priority_verified_in_get_work_event_.Signal();
     return nullptr;
   }
 
  private:
   void VerifyThreadPriority() {
     AutoSchedulerLock auto_lock(expected_thread_priority_lock_);
     EXPECT_EQ(expected_thread_priority_,
@@ skipping 63 matching lines @@
   // OnMainEntry() and GetWork() are called.
   worker->WakeUp();
   delegate_raw->WaitForPriorityVerifiedInGetWork();
 
   worker->JoinForTesting();
 }
 
 }  // namespace
 }  // namespace internal
 }  // namespace base