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

base/task_scheduler/scheduler_worker.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 <utility>
 
@@ skipping 18 matching lines @@
     if (thread->thread_handle_.is_null())
       return nullptr;
     return thread;
   }
 
   // PlatformThread::Delegate.
   void ThreadMain() override {
     // Set if this thread was detached.
     std::unique_ptr<Thread> detached_thread;
 
-    outer_->delegate_->OnMainEntry(
-        outer_, outer_->last_detach_time_.is_null()
-                    ? TimeDelta::Max()
-                    : TimeTicks::Now() - outer_->last_detach_time_);
+    outer_->delegate_->OnMainEntry(outer_);
 
     // A SchedulerWorker starts out waiting for work.
     WaitForWork();
 
     while (!outer_->task_tracker_->IsShutdownComplete() &&
            !outer_->should_exit_for_testing_.IsSet()) {
       DCHECK(outer_);
 
 #if defined(OS_MACOSX)
       mac::ScopedNSAutoreleasePool autorelease_pool;
 #endif
 
       UpdateThreadPriority(GetDesiredThreadPriority());
 
       // Get the sequence containing the next task to execute.
       scoped_refptr<Sequence> sequence = outer_->delegate_->GetWork(outer_);
       if (!sequence) {
         if (outer_->delegate_->CanDetach(outer_)) {
           detached_thread = outer_->Detach();
           if (detached_thread) {
+            outer_ = nullptr;
             DCHECK_EQ(detached_thread.get(), this);
             PlatformThread::Detach(thread_handle_);
-            outer_ = nullptr;
             break;
           }
         }
         WaitForWork();
         continue;
       }
 
       std::unique_ptr<Task> task = sequence->TakeTask();
       const TaskPriority task_priority = task->traits.priority();
       const TimeDelta task_latency = TimeTicks::Now() - task->sequenced_time;
@@ skipping 175 matching lines @@
 }
 
 std::unique_ptr<SchedulerWorker::Thread> SchedulerWorker::Detach() {
   DCHECK(!should_exit_for_testing_.IsSet()) << "Worker was already joined";
   AutoSchedulerLock auto_lock(thread_lock_);
   // If a wakeup is pending, then a WakeUp() came in while we were deciding to
   // detach. This means we can't go away anymore since we would break the
   // guarantee that we call GetWork() after a successful wakeup.
   if (thread_->IsWakeUpPending())
     return nullptr;
-  last_detach_time_ = TimeTicks::Now();
+
+  // Call OnDetach() within the scope of |thread_lock_| to prevent the delegate
+  // from being used concurrently from an old and a new thread.
+  delegate_->OnDetach();
+
   return std::move(thread_);
 }
 
 void SchedulerWorker::CreateThread() {
   thread_ = Thread::Create(this);
 }
 
 void SchedulerWorker::CreateThreadAssertSynchronized() {
   thread_lock_.AssertAcquired();
   CreateThread();
 }
 
 }  // namespace internal
 }  // namespace base