WorkerThread: drop unnecessary interfaces to simplify

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 43 matching lines @@
     DontPauseWorkerGlobalScopeOnStart,
     PauseWorkerGlobalScopeOnStart
 };
 
 // TODO(sadrul): Rename to WorkerScript.
 class CORE_EXPORT WorkerThread : public RefCounted<WorkerThread> {
 public:
     virtual ~WorkerThread();
 
     // Called on the main thread.
-    virtual void start(PassOwnPtr<WorkerThreadStartupData>);
-    virtual void stop();
+    void start(PassOwnPtr<WorkerThreadStartupData>);
+    void terminate();
 
     // Returns the thread this worker runs on. Some implementations can create
     // a new thread on the first call (e.g. shared, dedicated workers), whereas
     // some implementations can use an existing thread that is already being
     // used by other workers (e.g.  compositor workers).
     virtual WebThreadSupportingGC& backingThread() = 0;
 
-    virtual void didStartRunLoop();
     virtual void didStopRunLoop();
 
     v8::Isolate* isolate() const { return m_isolate; }
 
     // Can be used to wait for this worker thread to shut down.
-    // (This is signalled on the main thread, so it's assumed to be waited on the worker context thread)
+    // (This is signaled on the main thread, so it's assumed to be waited on
+    // the worker context thread)
     WebWaitableEvent* shutdownEvent() { return m_shutdownEvent.get(); }
 
-    WebWaitableEvent* terminationEvent() { return m_terminationEvent.get(); }
-
-    // Called in shutdown sequence. Internally calls stop() (or stopInternal)
-    // and wait (by *blocking* the calling thread) until the worker(s) is/are
-    // shut down.
+    // Called in shutdown sequence. Internally calls terminate() (or
+    // terminateInternal) and wait (by *blocking* the calling thread) until the
+    // worker(s) is/are shut down.
     void terminateAndWait();
     static void terminateAndWaitForAllWorkers();
 
     bool isCurrentThread();
     WorkerLoaderProxy* workerLoaderProxy() const
     {
         RELEASE_ASSERT(m_workerLoaderProxy);
         return m_workerLoaderProxy.get();
     }
 
     WorkerReportingProxy& workerReportingProxy() const { return m_workerReportingProxy; }
 
     void postTask(const WebTraceLocation&, PassOwnPtr<ExecutionContextTask>);
     void appendDebuggerTask(PassOwnPtr<WebThread::Task>);
 
     enum WaitMode { WaitForMessage, DontWaitForMessage };
     MessageQueueWaitResult runDebuggerTask(WaitMode = WaitForMessage);
 
     // These methods should be called if the holder of the thread is
     // going to call runDebuggerTask in a loop.
     void willEnterNestedLoop();
     void didLeaveNestedLoop();
 
     WorkerGlobalScope* workerGlobalScope() const { return m_workerGlobalScope.get(); }
 
-    // Returns true once stop() (or one of the terminate* methods which
-    // internally calls stop) is called.
+    // Returns true once one of the terminate* methods is called.
     bool terminated();
 
     // Number of active worker threads.
     static unsigned workerThreadCount();
 
     PlatformThreadId platformThreadId();
 
     void interruptAndDispatchInspectorCommands();
     void setWorkerInspectorController(WorkerInspectorController*);
 
@@ skipping 10 matching lines @@
     virtual void destroyIsolate();
     virtual void terminateV8Execution();
 
     // This is protected virtual for testing.
     virtual bool doIdleGc(double deadlineSeconds);
 
 private:
     friend class WorkerMicrotaskRunner;
 
     // Called on the main thread.
-    void stopInternal();
+    virtual void didStartRunLoop();

[kinuko, 2015/06/11 08:42:33]

nit: It's subjective but I think I'd like to keep this next to didStopRunLoop,
it'd make better sense when they're paired imo.

[Takashi Toyoshima, 2015/06/11 11:25:59]

Sounds reasonable. If we could stop calling didStopRunLoop() from
WorkerScriptController, it would be great. It looks a workaround to avoid an old
security issue, but for now I'm not sure we can remove it after cleaning up the
thread termination steps.

Anyway, I'll revert this part in this change.

+    void terminateInternal();
 
     // Called on the worker thread.
     void initialize(PassOwnPtr<WorkerThreadStartupData>);
     void shutdown();
     void performIdleWork(double deadlineSeconds);
     void postDelayedTask(const WebTraceLocation&, PassOwnPtr<ExecutionContextTask>, long long delayMs);
 
     bool m_started;
     bool m_terminated;
     bool m_shutdown;
@@ skipping 18 matching lines @@
     // Used to signal thread shutdown.
     OwnPtr<WebWaitableEvent> m_shutdownEvent;
 
     // Used to signal thread termination.
     OwnPtr<WebWaitableEvent> m_terminationEvent;
 };
 
 } // namespace blink
 
 #endif // WorkerThread_h