Worker: Protect a running debugger task from forcible worker termination

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 42 matching lines @@
     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.
+//
+// When termination starts, (debugger) tasks on WorkerThread are handled as
+// follows:
+//  - A running task may finish unless a forcible termination task interrupts.
+//    If the running task is for debugger, it's guaranteed to finish without
+//    any interruptions.
+//  - Queued tasks never run.
+//  - postTask() and appendDebuggerTask() reject posting new tasks.
 class CORE_EXPORT WorkerThread {
 public:
     // Represents how this thread is terminated.
     enum class ExitCode {
         NotTerminated,
         GracefullyTerminated,
         SyncForciblyTerminated,
         AsyncForciblyTerminated,
     };
 
@@ skipping 23 matching lines @@
     {
         RELEASE_ASSERT(m_workerLoaderProxy);
         return m_workerLoaderProxy.get();
     }
 
     WorkerReportingProxy& workerReportingProxy() const { return m_workerReportingProxy; }
 
     void postTask(const WebTraceLocation&, std::unique_ptr<ExecutionContextTask>);
     void appendDebuggerTask(std::unique_ptr<CrossThreadClosure>);
 
-    // Runs only debugger tasks while paused in debugger, called on the worker
-    // thread.
-    void startRunningDebuggerTasksOnPause();
-    void stopRunningDebuggerTasksOnPause();
-    bool isRunningDebuggerTasksOnPause() const { return m_pausedInDebugger; }
+    // Runs only debugger tasks while paused in debugger.
+    void startRunningDebuggerTasksOnPauseOnWorkerThread();
+    void stopRunningDebuggerTasksOnPauseOnWorkerThread();
 
     // Can be called only on the worker thread, WorkerGlobalScope is not thread
     // safe.
     WorkerGlobalScope* workerGlobalScope();
 
     // Returns true once one of the terminate* methods is called.
     bool terminated();
 
     // Number of active worker threads.
     static unsigned workerThreadCount();
@@ skipping 32 matching lines @@
 
     std::unique_ptr<CrossThreadClosure> createWorkerThreadTask(std::unique_ptr<ExecutionContextTask>, bool isInstrumented);
 
     void terminateInternal(TerminationMode);
     void forciblyTerminateExecution();
 
     void initializeOnWorkerThread(PassOwnPtr<WorkerThreadStartupData>);
     void prepareForShutdownOnWorkerThread();
     void performShutdownOnWorkerThread();
     void performTaskOnWorkerThread(std::unique_ptr<ExecutionContextTask>, bool isInstrumented);
-    void runDebuggerTaskOnWorkerThread(std::unique_ptr<CrossThreadClosure>);
-    void runDebuggerTaskDontWaitOnWorkerThread();
+    void performDebuggerTaskOnWorkerThread(std::unique_ptr<CrossThreadClosure>);
+    void performDebuggerTaskDontWaitOnWorkerThread();
 
     void setForceTerminationDelayInMsForTesting(long long forceTerminationDelayInMs) { m_forceTerminationDelayInMs = forceTerminationDelayInMs; }
 
     bool m_started = false;
     bool m_terminated = false;
     bool m_readyToShutdown = false;
     bool m_pausedInDebugger = false;
     bool m_runningDebuggerTask = false;
     ExitCode m_exitCode = ExitCode::NotTerminated;
 
@@ skipping 19 matching lines @@
     OwnPtr<WaitableEvent> m_shutdownEvent;
 
     // Scheduled when termination starts with TerminationMode::Force, and
     // cancelled when the worker thread is gracefully shut down.
     OwnPtr<ForceTerminationTask> m_scheduledForceTerminationTask;
 };
 
 } // namespace blink
 
 #endif // WorkerThread_h