Worker: Introduce an observation mechanism for WorkerThread termination

third_party/WebKit/Source/core/workers/WorkerThread.cpp

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 136 matching lines @@
     DEFINE_THREAD_SAFE_STATIC_LOCAL(Mutex, mutex, new Mutex);
     return mutex;
 }
 
 static HashSet<WorkerThread*>& workerThreads()
 {
     DEFINE_STATIC_LOCAL(HashSet<WorkerThread*>, threads, ());
     return threads;
 }
 
+WorkerThreadContext::WorkerThreadContext()
+{
+    DCHECK(isMainThread());
+}
+
+WorkerThreadContext::~WorkerThreadContext()
+{
+    DCHECK(isMainThread());
+}
+
+void WorkerThreadContext::notifyContextDestroyed()
+{
+    DCHECK(isMainThread());
+    DCHECK(!m_wasContextDestroyed);
+    m_wasContextDestroyed = true;
+    LifecycleNotifier::notifyContextDestroyed();
+}
+
 WorkerThread::~WorkerThread()
 {
     DCHECK(isMainThread());
     MutexLocker lock(threadSetMutex());
     DCHECK(workerThreads().contains(this));
     workerThreads().remove(this);
 
     DCHECK_NE(ExitCode::NotTerminated, m_exitCode);
     DEFINE_THREAD_SAFE_STATIC_LOCAL(EnumerationHistogram, exitCodeHistogram, new EnumerationHistogram("WorkerThread.ExitCode", static_cast<int>(ExitCode::LastEnum)));
     exitCodeHistogram.count(static_cast<int>(m_exitCode));
@@ skipping 133 matching lines @@
     : m_forceTerminationDelayInMs(kForceTerminationDelayInMs)
     , m_inspectorTaskRunner(adoptPtr(new InspectorTaskRunner()))
     , m_workerLoaderProxy(workerLoaderProxy)
     , m_workerReportingProxy(workerReportingProxy)
     , m_terminationEvent(adoptPtr(new WaitableEvent(
         WaitableEvent::ResetPolicy::Manual,
         WaitableEvent::InitialState::NonSignaled)))
     , m_shutdownEvent(adoptPtr(new WaitableEvent(
         WaitableEvent::ResetPolicy::Manual,
         WaitableEvent::InitialState::NonSignaled)))
+    , m_workerThreadContext(new WorkerThreadContext)
 {
+    DCHECK(isMainThread());
     MutexLocker lock(threadSetMutex());
     workerThreads().add(this);
 }
 
 std::unique_ptr<CrossThreadClosure> WorkerThread::createWorkerThreadTask(std::unique_ptr<ExecutionContextTask> task, bool isInstrumented)
 {
     if (isInstrumented)
         isInstrumented = !task->taskNameForInstrumentation().isEmpty();
     if (isInstrumented) {
         DCHECK(isCurrentThread());
@@ skipping 26 matching lines @@
             m_exitCode = ExitCode::SyncForciblyTerminated;
         }
         return;
     }
     m_terminated = true;
 
     // Signal the thread to notify that the thread's stopping.
     if (m_terminationEvent)
         m_terminationEvent->signal();
 
+    m_workerThreadContext->notifyContextDestroyed();
+
     // If the worker thread was never initialized, don't start another
     // shutdown, but still wait for the thread to signal when shutdown has
     // completed on initializeOnWorkerThread().
     if (!m_workerGlobalScope) {
         DCHECK_EQ(ExitCode::NotTerminated, m_exitCode);
         m_exitCode = ExitCode::GracefullyTerminated;
         return;
     }
 
     // Determine if we should synchronously terminate or schedule to terminate
@@ skipping 220 matching lines @@
         (*task)();
 }
 
 WorkerThread::ExitCode WorkerThread::getExitCode()
 {
     MutexLocker lock(m_threadStateMutex);
     return m_exitCode;
 }
 
 } // namespace blink