workers: Rename WorkerThread to WorkerScript.

Source/core/workers/WorkerGlobalScope.cpp

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  * Copyright (C) 2009, 2011 Google 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
@@ skipping 41 matching lines @@
 #include "core/inspector/WorkerInspectorController.h"
 #include "core/loader/WorkerThreadableLoader.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/workers/WorkerNavigator.h"
 #include "core/workers/WorkerClients.h"
 #include "core/workers/WorkerConsole.h"
 #include "core/workers/WorkerLoaderProxy.h"
 #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"
 #include "public/platform/WebURLRequest.h"
 
 namespace blink {
 
 class CloseWorkerGlobalScopeTask : public ExecutionContextTask {
 public:
     static PassOwnPtr<CloseWorkerGlobalScopeTask> create()
     {
         return adoptPtr(new CloseWorkerGlobalScopeTask);
     }
 
     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))
     , m_workerClients(workerClients)
     , m_timeOrigin(timeOrigin)
     , m_messageStorage(ConsoleMessageStorage::create())
     , m_workerExceptionUniqueIdentifier(0)
 {
     setSecurityOrigin(SecurityOrigin::create(url));
     if (starterOrigin)
         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);
 }
 
 void WorkerGlobalScope::applyContentSecurityPolicyFromString(const String& policy, ContentSecurityPolicyHeaderType contentSecurityPolicyType)
 {
     // FIXME: This doesn't match the CSP2 spec's Worker behavior (see https://w3c.github.io/webappsec/specs/content-security-policy/#processing-model-workers)
     RefPtr<ContentSecurityPolicy> csp = ContentSecurityPolicy::create();
     csp->didReceiveHeader(policy, contentSecurityPolicyType, ContentSecurityPolicyHeaderSourceHTTP);
     csp->bindToExecutionContext(executionContext());
     setContentSecurityPolicy(csp);
@@ skipping 24 matching lines @@
     return KURL(m_url, url);
 }
 
 String WorkerGlobalScope::userAgent(const KURL&) const
 {
     return m_userAgent;
 }
 
 void WorkerGlobalScope::disableEval(const String& errorMessage)
 {
-    m_script->disableEval(errorMessage);
+    m_scriptController->disableEval(errorMessage);
 }
 
 double WorkerGlobalScope::timerAlignmentInterval() const
 {
     return DOMTimer::visiblePageAlignmentInterval();
 }
 
 DOMTimerCoordinator* WorkerGlobalScope::timers()
 {
     return &m_timers;
@@ skipping 27 matching lines @@
 
 WorkerNavigator* WorkerGlobalScope::navigator() const
 {
     if (!m_navigator)
         m_navigator = WorkerNavigator::create(m_userAgent);
     return m_navigator.get();
 }
 
 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.
 }
 
 void WorkerGlobalScope::didEvaluateWorkerScript()
 {
 }
 
 void WorkerGlobalScope::importScripts(const Vector<String>& urls, ExceptionState& exceptionState)
 {
     ASSERT(contentSecurityPolicy());
@@ skipping 25 matching lines @@
             exceptionState.throwDOMException(NetworkError, "The script at '" + completeURL.elidedString() + "' failed to load.");
             return;
         }
 
         InspectorInstrumentation::scriptImported(&executionContext, scriptLoader->identifier(), scriptLoader->script());
         scriptLoaded(scriptLoader->script().length(), scriptLoader->cachedMetadata() ? scriptLoader->cachedMetadata()->size() : 0);
 
         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;
         }
     }
 }
 
 EventTarget* WorkerGlobalScope::errorEventTarget()
 {
     return this;
 }
 
 void WorkerGlobalScope::logExceptionToConsole(const String& errorMessage, int, const String& sourceURL, int lineNumber, int columnNumber, PassRefPtrWillBeRawPtr<ScriptCallStack> callStack)
 {
     unsigned long exceptionId = ++m_workerExceptionUniqueIdentifier;
     RefPtrWillBeRawPtr<ConsoleMessage> consoleMessage = ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, errorMessage, sourceURL, lineNumber);
     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)
 {
     InspectorInstrumentation::scriptExecutionBlockedByCSP(this, directiveText);
 }
 
 void WorkerGlobalScope::addConsoleMessage(PassRefPtrWillBeRawPtr<ConsoleMessage> prpConsoleMessage)
 {
     RefPtrWillBeRawPtr<ConsoleMessage> consoleMessage = prpConsoleMessage;
     if (!isContextThread()) {
         postTask(FROM_HERE, AddConsoleMessageTask::create(consoleMessage->source(), consoleMessage->level(), consoleMessage->message()));
         return;
     }
-    thread()->workerReportingProxy().reportConsoleMessage(consoleMessage);
+    script()->workerReportingProxy().reportConsoleMessage(consoleMessage);
     addMessageToWorkerConsole(consoleMessage.release());
 }
 
 void WorkerGlobalScope::addMessageToWorkerConsole(PassRefPtrWillBeRawPtr<ConsoleMessage> consoleMessage)
 {
     ASSERT(isContextThread());
     m_messageStorage->reportMessage(this, consoleMessage);
 }
 
 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
 {
     return m_eventQueue.get();
 }
 
 void WorkerGlobalScope::countFeature(UseCounter::Feature) const
 {
     // FIXME: How should we count features for shared/service workers?
@@ skipping 26 matching lines @@
         addConsoleMessage(consoleMessage.release());
 }
 
 bool WorkerGlobalScope::isPrivilegedContext(String& errorMessage, const PrivilegeContextCheck privilegeContextCheck)
 {
     // Until there are APIs that are available in workers and that
     // require a privileged context test that checks ancestors, just do
     // 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)
 {
     memoryCache()->removeURLFromCache(url);
 }
 
 v8::Local<v8::Object> WorkerGlobalScope::wrap(v8::Isolate*, v8::Local<v8::Object> creationContext)
 {
     // WorkerGlobalScope must never be wrapped with wrap method.  The global
@@ skipping 20 matching lines @@
     visitor->trace(m_timers);
     visitor->trace(m_messageStorage);
     visitor->trace(m_pendingMessages);
     HeapSupplementable<WorkerGlobalScope>::trace(visitor);
 #endif
     ExecutionContext::trace(visitor);
     EventTargetWithInlineData::trace(visitor);
 }
 
 } // namespace blink