[NOT READY FOR REVIEW YET]workers: Some refactoring to allow creating new kind of worker threads

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 21 matching lines @@
 #include "core/workers/WorkerGlobalScope.h"
 #include "platform/SharedTimer.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"
 
+namespace v8 {
+class Isolate;
+}
+
 namespace blink {
 
 class WebWaitableEvent;
 class WorkerGlobalScope;
 class WorkerInspectorController;
 class WorkerLoaderProxy;
 class WorkerReportingProxy;
 class WorkerSharedTimer;
 class WorkerThreadShutdownFinishTask;
 class WorkerThreadStartupData;
 class WorkerThreadTask;
 
 enum WorkerThreadStartMode {
     DontPauseWorkerGlobalScopeOnStart,
     PauseWorkerGlobalScopeOnStart
 };
 
 class WorkerThread : public RefCounted<WorkerThread> {
 public:
     virtual ~WorkerThread();
 
     virtual void start();
     virtual void stop();
 
+    virtual v8::Isolate* initializeIsolate();
+    virtual PassOwnPtr<WebThreadSupportingGC> createWebThreadSupportingGC();
+
     // 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() const;
     WorkerLoaderProxy& workerLoaderProxy() const { return m_workerLoaderProxy; }
@@ skipping 10 matching lines @@
     void willEnterNestedLoop();
     void didLeaveNestedLoop();
 
     WorkerGlobalScope* workerGlobalScope() const { return m_workerGlobalScope.get(); }
     bool terminated();
 
     // Number of active worker threads.
     static unsigned workerThreadCount();
 
     PlatformThreadId platformThreadId() const;
+    v8::Isolate* isolate() const;
 
     void interruptAndDispatchInspectorCommands();
     void setWorkerInspectorController(WorkerInspectorController*);
 
 protected:
     WorkerThread(WorkerLoaderProxy&, WorkerReportingProxy&, PassOwnPtrWillBeRawPtr<WorkerThreadStartupData>);
 
     // Factory method for creating a new worker context for the thread.
     virtual PassRefPtrWillBeRawPtr<WorkerGlobalScope> createWorkerGlobalScope(PassOwnPtrWillBeRawPtr<WorkerThreadStartupData>) = 0;
 
@@ skipping 25 matching lines @@
     Mutex m_threadCreationMutex;
     RefPtrWillBePersistent<WorkerGlobalScope> m_workerGlobalScope;
     OwnPtrWillBePersistent<WorkerThreadStartupData> m_startupData;
 
     // Used to signal thread shutdown.
     OwnPtr<WebWaitableEvent> m_shutdownEvent;
 
     // Used to signal thread termination.
     OwnPtr<WebWaitableEvent> m_terminationEvent;
 
+    v8::Isolate* m_isolate;
+
     // FIXME: This has to be last because of crbug.com/401397 - the
     // WorkerThread might get deleted before it had a chance to properly
     // shut down. By deleting the WebThread first, we can guarantee that
     // no pending tasks on the thread might want to access any of the other
     // members during the WorkerThread's destruction.
     OwnPtr<WebThreadSupportingGC> m_thread;
 };
 
 } // namespace blink
 
 #endif // WorkerThread_h