Worker: Make WorkerMicrotaskRunner a private inner class of WorkerThread

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 33 matching lines @@
 #include "platform/heap/ThreadState.h"
 #include "platform/weborigin/KURL.h"
 #include "public/platform/WebThread.h"
 #include "wtf/Functional.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/text/WTFString.h"
 #include <limits.h>
 
 namespace blink {
 
-class WorkerMicrotaskRunner : public WebThread::TaskObserver {
+class WorkerThread::WorkerMicrotaskRunner : public WebThread::TaskObserver {
 public:
     explicit WorkerMicrotaskRunner(WorkerThread* workerThread)
         : m_workerThread(workerThread)
     {
     }
 
     void willProcessTask() override
     {
         // No tasks should get executed after we have closed.
         DCHECK(!m_workerThread->workerGlobalScope() || !m_workerThread->workerGlobalScope()->isClosing());
@@ skipping 166 matching lines @@
     }
 
     CachedMetadataHandler* handler = workerGlobalScope()->createWorkerScriptCachedMetadataHandler(scriptURL, cachedMetaData.get());
     bool success = m_workerGlobalScope->scriptController()->evaluate(ScriptSourceCode(sourceCode, scriptURL), nullptr, handler, v8CacheOptions);
     m_workerGlobalScope->didEvaluateWorkerScript();
     m_workerReportingProxy.didEvaluateWorkerScript(success);
 
     postInitialize();
 }
 
-void WorkerThread::performShutdownTask()
+void WorkerThread::prepareForShutdown()
+{
+    DCHECK(isCurrentThread());
+    {
+        MutexLocker lock(m_threadStateMutex);
+        if (m_readyToShutdown)
+            return;
+        m_readyToShutdown = true;
+    }
+
+    workerReportingProxy().willDestroyWorkerGlobalScope();
+    InspectorInstrumentation::allAsyncTasksCanceled(workerGlobalScope());
+    workerGlobalScope()->dispose();
+    workerBackingThread().backingThread().removeTaskObserver(m_microtaskRunner.get());
+}
+
+void WorkerThread::performShutdown()
 {
     DCHECK(isCurrentThread());
 #if DCHECK_IS_ON
     {
         MutexLocker lock(m_threadStateMutex);
         DCHECK(m_terminated);
         DCHECK(m_readyToShutdown);
     }
 #endif
 
@@ skipping 70 matching lines @@
             } else {
                 // TODO(yhirano): TerminateExecution should be called more
                 // carefully (https://crbug.com/413518).
                 isolate()->TerminateExecution();
             }
         }
     }
 
     m_inspectorTaskRunner->kill();
     workerBackingThread().backingThread().postTask(BLINK_FROM_HERE, threadSafeBind(&WorkerThread::prepareForShutdown, AllowCrossThreadAccess(this)));
-    workerBackingThread().backingThread().postTask(BLINK_FROM_HERE, threadSafeBind(&WorkerThread::performShutdownTask, AllowCrossThreadAccess(this)));
+    workerBackingThread().backingThread().postTask(BLINK_FROM_HERE, threadSafeBind(&WorkerThread::performShutdown, AllowCrossThreadAccess(this)));
 }
 
 void WorkerThread::terminateAndWait()
 {
     DCHECK(isMainThread());
     terminate();
     m_shutdownEvent->wait();
 }
 
 void WorkerThread::terminateAndWaitForAllWorkers()
 {
     DCHECK(isMainThread());
 
     // Keep this lock to prevent WorkerThread instances from being destroyed.
     MutexLocker lock(threadSetMutex());
     HashSet<WorkerThread*> threads = workerThreads();
     for (WorkerThread* thread : threads)
         thread->terminate();
 
     for (WorkerThread* thread : threads)
         thread->m_shutdownEvent->wait();
 }
 
-void WorkerThread::prepareForShutdown()
-{
-    DCHECK(isCurrentThread());
-    {
-        MutexLocker lock(m_threadStateMutex);
-        if (m_readyToShutdown)
-            return;
-        m_readyToShutdown = true;
-    }
-
-    workerReportingProxy().willDestroyWorkerGlobalScope();
-    InspectorInstrumentation::allAsyncTasksCanceled(workerGlobalScope());
-    workerGlobalScope()->dispose();
-    workerBackingThread().backingThread().removeTaskObserver(m_microtaskRunner.get());
-}
-
 WorkerGlobalScope* WorkerThread::workerGlobalScope()
 {
     DCHECK(isCurrentThread());
     return m_workerGlobalScope.get();
 }
 
 bool WorkerThread::terminated()
 {
     MutexLocker lock(m_threadStateMutex);
     return m_terminated;
@@ skipping 75 matching lines @@
     } while (task && m_pausedInDebugger);
     ThreadDebugger::idleFinished(isolate());
 }
 
 void WorkerThread::stopRunningDebuggerTasksOnPause()
 {
     m_pausedInDebugger = false;
 }
 
 } // namespace blink