compositor-worker: Share a thread and an isolate for compositor workers.

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 13 matching lines @@
  *
  */
 
 #ifndef WorkerThread_h
 #define WorkerThread_h
 
 #include "core/CoreExport.h"
 #include "core/dom/ExecutionContextTask.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/workers/WorkerGlobalScope.h"
+#include "core/workers/WorkerIsolateWrapper.h"
 #include "core/workers/WorkerLoaderProxy.h"
 #include "platform/WebThreadSupportingGC.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "wtf/Forward.h"
 #include "wtf/MessageQueue.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefCounted.h"
 #include <v8.h>
 
@@ skipping 18 matching lines @@
     virtual ~WorkerThread();
 
     virtual void start(PassOwnPtr<WorkerThreadStartupData>);
     virtual void stop();
 
     // 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; }
+    v8::Isolate* 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)
     WebWaitableEvent* shutdownEvent() { return m_shutdownEvent.get(); }
 
     WebWaitableEvent* terminationEvent() { return m_terminationEvent.get(); }
     void terminateAndWait();
     static void terminateAndWaitForAllWorkers();
 
     bool isCurrentThread();
@@ skipping 28 matching lines @@
     void setWorkerInspectorController(WorkerInspectorController*);
 
 protected:
     WorkerThread(PassRefPtr<WorkerLoaderProxy>, WorkerReportingProxy&);
 
     // Factory method for creating a new worker context for the thread.
     virtual PassRefPtrWillBeRawPtr<WorkerGlobalScope> createWorkerGlobalScope(PassOwnPtr<WorkerThreadStartupData>) = 0;
 
     virtual void postInitialize() { }
 
-    virtual v8::Isolate* initializeIsolate();
-    virtual void willDestroyIsolate();
-    virtual void destroyIsolate();
+    virtual PassOwnPtr<WorkerIsolateWrapper> createIsolateWrapper() = 0;

[kinuko, 2015/06/01 13:15:41]

Please comment that this needs to be called on the worker thread. (Also might be
nice to to put this after shutdownBackingThread so that the virtual methods that
are to be called on the worker thread are placed together)

[sadrul, 2015/06/01 14:21:16]

Done.

     virtual void terminateV8Execution();
 
+    virtual void initializeBackingThread();
+    virtual void shutdownBackingThread();

[kinuko, 2015/06/01 13:15:41]

Please comment that these need to be called on the worker thread.

[sadrul, 2015/06/01 14:21:16]

Done.

+
     // This is protected virtual for testing.
     virtual bool doIdleGc(double deadlineSeconds);
 
 private:
     friend class WorkerSharedTimer;
     friend class WorkerMicrotaskRunner;
 
     void stopInShutdownSequence();
     void stopInternal();
 
     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;
     MessageQueue<WebThread::Task> m_debuggerMessageQueue;
     OwnPtr<WebThread::TaskObserver> m_microtaskRunner;
 
     RefPtr<WorkerLoaderProxy> m_workerLoaderProxy;
     WorkerReportingProxy& m_workerReportingProxy;
     RawPtr<WebScheduler> m_webScheduler; // Not owned.
 
     RefPtrWillBePersistent<WorkerInspectorController> m_workerInspectorController;
     Mutex m_workerInspectorControllerMutex;
 
-    // This lock protects |m_workerGlobalScope|, |m_terminated|, |m_isolate| and |m_microtaskRunner|.
+    // This lock protects |m_workerGlobalScope|, |m_terminated|, and |m_isolateWrapper|.
     Mutex m_threadStateMutex;
 
     RefPtrWillBePersistent<WorkerGlobalScope> m_workerGlobalScope;
-
-    v8::Isolate* m_isolate;
-    OwnPtr<V8IsolateInterruptor> m_interruptor;
+    OwnPtr<WorkerIsolateWrapper> m_isolateWrapper;
 
     // Used to signal thread shutdown.
     OwnPtr<WebWaitableEvent> m_shutdownEvent;
 
     // Used to signal thread termination.
     OwnPtr<WebWaitableEvent> m_terminationEvent;
 };
 
 } // namespace blink
 
 #endif // WorkerThread_h