Worker: Initiate worker thread shutdown always on the main thread

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

 /*
  * 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 40 matching lines @@
 
 enum WorkerThreadStartMode {
     DontPauseWorkerGlobalScopeOnStart,
     PauseWorkerGlobalScopeOnStart
 };
 
 // WorkerThread is a kind of WorkerBackingThread client. Each worker mechanism
 // can access the lower thread infrastructure via an implementation of this
 // abstract class. Multiple WorkerThreads can share one WorkerBackingThread.
 // See WorkerBackingThread.h for more details.
+//
+// WorkerThread start and termination must be initiated on the main thread and
+// an actual task is executed on the worker thread.
 class CORE_EXPORT WorkerThread {
 public:
     virtual ~WorkerThread();
 
     // Called on the main thread.
     void start(PassOwnPtr<WorkerThreadStartupData>);
     void terminate();
 
     // Called in shutdown sequence on the main thread. Internally calls
     // terminate() and wait (by *blocking* the calling thread) until the
     // worker(s) is/are shut down.
     void terminateAndWait();
     static void terminateAndWaitForAllWorkers();
 
-    // Called on the worker thread for WorkerGlobleScope::close().
-    void terminateFromWorkerThread();
+    // Called on the worker thread. Disposes |m_workerGlobalScope|.
+    void prepareForShutdown();

[kinuko, 2016/05/24 09:07:49]

nit: could we make WorkerMicroTaskRunner a private inner class of WorkerThread
and make this method private as well?  I don't feel this needs to be a public
method.

[nhiroki, 2016/05/24 13:36:06]

Agreed. I'll make a separate CL for this.

[nhiroki, 2016/05/25 01:58:33]

Uploaded a CL: https://codereview.chromium.org/2006273003/

 
     virtual WorkerBackingThread& workerBackingThread() = 0;
     virtual bool shouldAttachThreadDebugger() const { return true; }
     v8::Isolate* isolate();
 
     // Can be used to wait for this worker thread to terminate.
     // (This is signaled on the main thread, so it's assumed to be waited on
     // the worker context thread)
     WaitableEvent* terminationEvent() { return m_terminationEvent.get(); }
 
@@ skipping 35 matching lines @@
     virtual WorkerGlobalScope* createWorkerGlobalScope(PassOwnPtr<WorkerThreadStartupData>) = 0;
 
     // Called on the worker thread.
     virtual void postInitialize() { }
 
 private:
     std::unique_ptr<CrossThreadClosure> createWorkerThreadTask(std::unique_ptr<ExecutionContextTask>, bool isInstrumented);
 
     // Called on the worker thread.
     void initialize(PassOwnPtr<WorkerThreadStartupData>);
-    void shutdown();
     void performTask(std::unique_ptr<ExecutionContextTask>, bool isInstrumented);
     void performShutdownTask();
     void runDebuggerTask(std::unique_ptr<CrossThreadClosure>);
     void runDebuggerTaskDontWait();
 
-    bool m_started;
-    bool m_terminated;
-    bool m_shutdown;
-    bool m_pausedInDebugger;
-    bool m_runningDebuggerTask;
-    bool m_shouldTerminateV8Execution;
+    bool m_started = false;
+    bool m_terminated = false;
+    bool m_readyToShutdown = false;
+    bool m_pausedInDebugger = false;
+    bool m_runningDebuggerTask = false;
+    bool m_shouldTerminateV8Execution = false;
+
     OwnPtr<InspectorTaskRunner> m_inspectorTaskRunner;
     OwnPtr<WebThread::TaskObserver> m_microtaskRunner;
 
     RefPtr<WorkerLoaderProxy> m_workerLoaderProxy;
     WorkerReportingProxy& m_workerReportingProxy;
 
-    // This lock protects |m_workerGlobalScope|, |m_terminated|, |m_shutdown|,
-    // |m_runningDebuggerTask|, |m_shouldTerminateV8Execution| and
-    // |m_microtaskRunner|.
+    // This lock protects |m_workerGlobalScope|, |m_terminated|,
+    // |m_readyToShutdown|, |m_runningDebuggerTask|,
+    // |m_shouldTerminateV8Execution| and |m_microtaskRunner|.
     Mutex m_threadStateMutex;
 
     Persistent<WorkerGlobalScope> m_workerGlobalScope;
 
     // Signaled when the thread starts termination on the main thread.
     OwnPtr<WaitableEvent> m_terminationEvent;
 
     // Signaled when the thread completes termination on the worker thread.
     OwnPtr<WaitableEvent> m_shutdownEvent;
 };
 
 } // namespace blink
 
 #endif // WorkerThread_h