workers: Rename WorkerThread to WorkerScript.

Source/core/workers/WorkerGlobalScope.cpp

Index: Source/core/workers/WorkerGlobalScope.cpp
diff --git a/Source/core/workers/WorkerGlobalScope.cpp b/Source/core/workers/WorkerGlobalScope.cpp
index 1c0e3df625225876635810a810df379f5f1de242..3adf634a14271e5b2209881d93ee880d2be331f1 100644
--- a/Source/core/workers/WorkerGlobalScope.cpp
+++ b/Source/core/workers/WorkerGlobalScope.cpp
@@ -59,8 +59,8 @@
 #include "core/workers/WorkerLocation.h"
 #include "core/workers/WorkerNavigator.h"
 #include "core/workers/WorkerReportingProxy.h"
+#include "core/workers/WorkerScript.h"
 #include "core/workers/WorkerScriptLoader.h"
-#include "core/workers/WorkerThread.h"
 #include "platform/network/ContentSecurityPolicyParsers.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SecurityOrigin.h"
@@ -78,19 +78,19 @@ public:
     virtual void performTask(ExecutionContext *context)
     {
         WorkerGlobalScope* workerGlobalScope = toWorkerGlobalScope(context);
-        // Notify parent that this context is closed. Parent is responsible for calling WorkerThread::stop().
-        workerGlobalScope->thread()->workerReportingProxy().workerGlobalScopeClosed();
+        // Notify parent that this context is closed. Parent is responsible for calling WorkerScript::stop().
+        workerGlobalScope->script()->workerReportingProxy().workerGlobalScopeClosed();
     }
 
     virtual bool isCleanupTask() const { return true; }
 };
 
-WorkerGlobalScope::WorkerGlobalScope(const KURL& url, const String& userAgent, WorkerThread* thread, double timeOrigin, const SecurityOrigin* starterOrigin, PassOwnPtrWillBeRawPtr<WorkerClients> workerClients)
+WorkerGlobalScope::WorkerGlobalScope(const KURL& url, const String& userAgent, WorkerScript* script, double timeOrigin, const SecurityOrigin* starterOrigin, PassOwnPtrWillBeRawPtr<WorkerClients> workerClients)
     : m_url(url)
     , m_userAgent(userAgent)
     , m_v8CacheOptions(V8CacheOptionsDefault)
-    , m_script(adoptPtr(new WorkerScriptController(*this, thread->isolate())))
-    , m_thread(thread)
+    , m_scriptController(adoptPtr(new WorkerScriptController(*this, script->isolate())))
+    , m_script(script)
     , m_workerInspectorController(adoptRefWillBeNoop(new WorkerInspectorController(this)))
     , m_closing(false)
     , m_eventQueue(WorkerEventQueue::create(this))
@@ -104,12 +104,12 @@ WorkerGlobalScope::WorkerGlobalScope(const KURL& url, const String& userAgent, W
         securityOrigin()->transferPrivilegesFrom(*starterOrigin);
 
     m_workerClients->reattachThread();
-    m_thread->setWorkerInspectorController(m_workerInspectorController.get());
+    m_script->setWorkerInspectorController(m_workerInspectorController.get());
 }
 
 WorkerGlobalScope::~WorkerGlobalScope()
 {
-    ASSERT(!m_script);
+    ASSERT(!m_scriptController);
     ASSERT(!m_workerInspectorController);
 }
 
@@ -154,7 +154,7 @@ String WorkerGlobalScope::userAgent(const KURL&) const
 
 void WorkerGlobalScope::disableEval(const String& errorMessage)
 {
-    m_script->disableEval(errorMessage);
+    m_scriptController->disableEval(errorMessage);
 }
 
 double WorkerGlobalScope::timerAlignmentInterval() const
@@ -202,30 +202,30 @@ WorkerNavigator* WorkerGlobalScope::navigator() const
 
 void WorkerGlobalScope::postTask(const WebTraceLocation& location, PassOwnPtr<ExecutionContextTask> task)
 {
-    thread()->postTask(location, task);
+    script()->postTask(location, task);
 }
 
 void WorkerGlobalScope::clearInspector()
 {
     ASSERT(m_workerInspectorController);
-    thread()->setWorkerInspectorController(nullptr);
+    script()->setWorkerInspectorController(nullptr);
     m_workerInspectorController->dispose();
     m_workerInspectorController.clear();
 }
 
 void WorkerGlobalScope::dispose()
 {
-    ASSERT(thread()->isCurrentThread());
+    ASSERT(script()->isCurrentThread());
 
-    clearScript();
+    m_scriptController.clear();
     clearInspector();
     m_eventQueue->close();
 
-    // We do not clear the thread field of the
+    // We do not clear the script field of the
     // WorkerGlobalScope. Other objects keep the worker global scope
-    // alive because they need its thread field to check that work is
+    // alive because they need its script field to check that work is
     // being carried out on the right thread. We therefore cannot clear
-    // the thread field before all references to the worker global
+    // the script field before all references to the worker global
     // scope are gone.
 }
 
@@ -271,9 +271,9 @@ void WorkerGlobalScope::importScripts(const Vector<String>& urls, ExceptionState
         RefPtrWillBeRawPtr<ErrorEvent> errorEvent = nullptr;
         OwnPtr<Vector<char>> cachedMetaData(scriptLoader->releaseCachedMetadata());
         OwnPtr<CachedMetadataHandler> handler(createWorkerScriptCachedMetadataHandler(completeURL, cachedMetaData.get()));
-        m_script->evaluate(ScriptSourceCode(scriptLoader->script(), scriptLoader->responseURL()), &errorEvent, handler.get(), m_v8CacheOptions);
+        m_scriptController->evaluate(ScriptSourceCode(scriptLoader->script(), scriptLoader->responseURL()), &errorEvent, handler.get(), m_v8CacheOptions);
         if (errorEvent) {
-            m_script->rethrowExceptionFromImportedScript(errorEvent.release(), exceptionState);
+            m_scriptController->rethrowExceptionFromImportedScript(errorEvent.release(), exceptionState);
             return;
         }
     }
@@ -291,7 +291,7 @@ void WorkerGlobalScope::logExceptionToConsole(const String& errorMessage, int, c
     consoleMessage->setCallStack(callStack);
     m_pendingMessages.set(exceptionId, consoleMessage);
 
-    thread()->workerReportingProxy().reportException(errorMessage, lineNumber, columnNumber, sourceURL, exceptionId);
+    script()->workerReportingProxy().reportException(errorMessage, lineNumber, columnNumber, sourceURL, exceptionId);
 }
 
 void WorkerGlobalScope::reportBlockedScriptExecutionToInspector(const String& directiveText)
@@ -306,7 +306,7 @@ void WorkerGlobalScope::addConsoleMessage(PassRefPtrWillBeRawPtr<ConsoleMessage>
         postTask(FROM_HERE, AddConsoleMessageTask::create(consoleMessage->source(), consoleMessage->level(), consoleMessage->message()));
         return;
     }
-    thread()->workerReportingProxy().reportConsoleMessage(consoleMessage);
+    script()->workerReportingProxy().reportConsoleMessage(consoleMessage);
     addMessageToWorkerConsole(consoleMessage.release());
 }
 
@@ -318,12 +318,12 @@ void WorkerGlobalScope::addMessageToWorkerConsole(PassRefPtrWillBeRawPtr<Console
 
 bool WorkerGlobalScope::isContextThread() const
 {
-    return thread()->isCurrentThread();
+    return script()->isCurrentThread();
 }
 
 bool WorkerGlobalScope::isJSExecutionForbidden() const
 {
-    return m_script->isExecutionForbidden();
+    return m_scriptController->isExecutionForbidden();
 }
 
 WorkerEventQueue* WorkerGlobalScope::eventQueue() const
@@ -370,13 +370,13 @@ bool WorkerGlobalScope::isPrivilegedContext(String& errorMessage, const Privileg
     // a simple check here. Once we have a need for a real
     // |isPrivilegedContext| check here, we can check the responsible
     // document for a privileged context at worker creation time, pass
-    // it in via WorkerThreadStartupData, and check it here.
+    // it in via WorkerScriptStartupData, and check it here.
     return securityOrigin()->isPotentiallyTrustworthy(errorMessage);
 }
 
 void WorkerGlobalScope::removeURLFromMemoryCache(const KURL& url)
 {
-    m_thread->workerLoaderProxy()->postTaskToLoader(createCrossThreadTask(&WorkerGlobalScope::removeURLFromMemoryCacheInternal, url));
+    m_script->workerLoaderProxy()->postTaskToLoader(createCrossThreadTask(&WorkerGlobalScope::removeURLFromMemoryCacheInternal, url));
 }
 
 void WorkerGlobalScope::removeURLFromMemoryCacheInternal(const KURL& url)