Rename WorkerContext to WorkerGlobalScope

Source/WebKit/chromium/src/WebSharedWorkerImpl.cpp

 /*
  * Copyright (C) 2009 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 37 matching lines @@
 #include "core/dom/MessageEvent.h"
 #include "core/dom/MessagePortChannel.h"
 #include "core/dom/ScriptExecutionContext.h"
 #include "core/dom/default/chromium/PlatformMessagePortChannelChromium.h"
 #include "core/inspector/WorkerDebuggerAgent.h"
 #include "core/inspector/WorkerInspectorController.h"
 #include "core/loader/FrameLoadRequest.h"
 #include "core/loader/FrameLoader.h"
 #include "core/page/Page.h"
 #include "core/page/PageGroup.h"
-#include "core/workers/SharedWorkerContext.h"
+#include "core/workers/SharedWorkerGlobalScope.h"
 #include "core/workers/SharedWorkerThread.h"
-#include "core/workers/WorkerContext.h"
+#include "core/workers/WorkerGlobalScope.h"
 #include "core/workers/WorkerLoaderProxy.h"
 #include "core/workers/WorkerThread.h"
 #include "modules/webdatabase/DatabaseTask.h"
 #include "weborigin/KURL.h"
 #include "weborigin/SecurityOrigin.h"
 
 using namespace WebCore;
 
 namespace WebKit {
 
@@ skipping 200 matching lines @@
 
 void WebSharedWorkerImpl::reportPendingActivityTask(ScriptExecutionContext* context,
                                                     WebSharedWorkerImpl* thisPtr,
                                                     bool hasPendingActivity)
 {
     if (!thisPtr->client())
         return;
     thisPtr->client()->reportPendingActivity(hasPendingActivity);
 }
 
-void WebSharedWorkerImpl::workerContextClosed()
+void WebSharedWorkerImpl::workerGlobalScopeClosed()
 {
-    WebWorkerBase::dispatchTaskToMainThread(createCallbackTask(&workerContextClosedTask,
+    WebWorkerBase::dispatchTaskToMainThread(createCallbackTask(&workerGlobalScopeClosedTask,
                                             AllowCrossThreadAccess(this)));
 }
 
-void WebSharedWorkerImpl::workerContextClosedTask(ScriptExecutionContext* context,
+void WebSharedWorkerImpl::workerGlobalScopeClosedTask(ScriptExecutionContext* context,
                                                   WebSharedWorkerImpl* thisPtr)
 {
     if (thisPtr->client())
         thisPtr->client()->workerContextClosed();
 
     thisPtr->stopWorkerThread();
 }
 
-void WebSharedWorkerImpl::workerContextDestroyed()
+void WebSharedWorkerImpl::workerGlobalScopeDestroyed()
 {
-    WebWorkerBase::dispatchTaskToMainThread(createCallbackTask(&workerContextDestroyedTask,
+    WebWorkerBase::dispatchTaskToMainThread(createCallbackTask(&workerGlobalScopeDestroyedTask,
                                                                AllowCrossThreadAccess(this)));
 }
 
-void WebSharedWorkerImpl::workerContextDestroyedTask(ScriptExecutionContext* context,
+void WebSharedWorkerImpl::workerGlobalScopeDestroyedTask(ScriptExecutionContext* context,
                                                      WebSharedWorkerImpl* thisPtr)
 {
     if (thisPtr->client())
         thisPtr->client()->workerContextDestroyed();
     // The lifetime of this proxy is controlled by the worker context.
     delete thisPtr;
 }
 
 // WorkerLoaderProxy -----------------------------------------------------------
 
 void WebSharedWorkerImpl::postTaskToLoader(PassOwnPtr<ScriptExecutionContext::Task> task)
 {
     ASSERT(m_loadingDocument->isDocument());
     m_loadingDocument->postTask(task);
 }
 
-bool WebSharedWorkerImpl::postTaskForModeToWorkerContext(
+bool WebSharedWorkerImpl::postTaskForModeToWorkerGlobalScope(
     PassOwnPtr<ScriptExecutionContext::Task> task, const String& mode)
 {
     m_workerThread->runLoop().postTaskForMode(task, mode);
     return true;
 }
 
 WebWorkerBase* WebSharedWorkerImpl::toWebWorkerBase()
 {
     return this;
 }
@@ skipping 19 matching lines @@
         createCallbackTask(&connectTask, channel.release()));
     if (listener)
         listener->connected();
 }
 
 void WebSharedWorkerImpl::connectTask(ScriptExecutionContext* context, PassOwnPtr<MessagePortChannel> channel)
 {
     // Wrap the passed-in channel in a MessagePort, and send it off via a connect event.
     RefPtr<MessagePort> port = MessagePort::create(*context);
     port->entangle(channel);
-    ASSERT_WITH_SECURITY_IMPLICATION(context->isWorkerContext());
-    WorkerContext* workerContext = static_cast<WorkerContext*>(context);
-    ASSERT_WITH_SECURITY_IMPLICATION(workerContext->isSharedWorkerContext());
-    workerContext->dispatchEvent(createConnectEvent(port));
+    ASSERT_WITH_SECURITY_IMPLICATION(context->isWorkerGlobalScope());
+    WorkerGlobalScope* workerGlobalScope = static_cast<WorkerGlobalScope*>(context);
+    ASSERT_WITH_SECURITY_IMPLICATION(workerGlobalScope->isSharedWorkerGlobalScope());
+    workerGlobalScope->dispatchEvent(createConnectEvent(port));
 }
 
 void WebSharedWorkerImpl::startWorkerContext(const WebURL& url, const WebString& name, const WebString& userAgent, const WebString& sourceCode, const WebString& contentSecurityPolicy, WebContentSecurityPolicyType policyType, long long)
 {
     initializeLoader(url);
-    WorkerThreadStartMode startMode = m_pauseWorkerContextOnStart ? PauseWorkerContextOnStart : DontPauseWorkerContextOnStart;
+    WorkerThreadStartMode startMode = m_pauseWorkerContextOnStart ? PauseWorkerGlobalScopeOnStart : DontPauseWorkerGlobalScopeOnStart;
     setWorkerThread(SharedWorkerThread::create(name, url, userAgent,
                                                sourceCode, *this, *this, startMode, contentSecurityPolicy,
                                                static_cast<WebCore::ContentSecurityPolicy::HeaderType>(policyType)));
 
     workerThread()->start();
 }
 
 void WebSharedWorkerImpl::terminateWorkerContext()
 {
     stopWorkerThread();
 }
 
 void WebSharedWorkerImpl::clientDestroyed()
 {
     m_client = 0;
 }
 
 void WebSharedWorkerImpl::pauseWorkerContextOnStart()
 {
     m_pauseWorkerContextOnStart = true;
 }
 
 static void resumeWorkerContextTask(ScriptExecutionContext* context, bool)
 {
-    ASSERT_WITH_SECURITY_IMPLICATION(context->isWorkerContext());
-    static_cast<WorkerContext*>(context)->workerInspectorController()->resume();
+    ASSERT_WITH_SECURITY_IMPLICATION(context->isWorkerGlobalScope());
+    static_cast<WorkerGlobalScope*>(context)->workerInspectorController()->resume();
 }
 
 void WebSharedWorkerImpl::resumeWorkerContext()
 {
     m_pauseWorkerContextOnStart = false;
     if (workerThread())
         workerThread()->runLoop().postTaskForMode(createCallbackTask(resumeWorkerContextTask, true), WorkerDebuggerAgent::debuggerTaskMode);
 }
 
 static void connectToWorkerContextInspectorTask(ScriptExecutionContext* context, bool)
 {
-    ASSERT_WITH_SECURITY_IMPLICATION(context->isWorkerContext());
-    static_cast<WorkerContext*>(context)->workerInspectorController()->connectFrontend();
+    ASSERT_WITH_SECURITY_IMPLICATION(context->isWorkerGlobalScope());
+    static_cast<WorkerGlobalScope*>(context)->workerInspectorController()->connectFrontend();
 }
 
 void WebSharedWorkerImpl::attachDevTools()
 {
     workerThread()->runLoop().postTaskForMode(createCallbackTask(connectToWorkerContextInspectorTask, true), WorkerDebuggerAgent::debuggerTaskMode);
 }
 
 static void reconnectToWorkerContextInspectorTask(ScriptExecutionContext* context, const String& savedState)
 {
-    ASSERT_WITH_SECURITY_IMPLICATION(context->isWorkerContext());
-    WorkerInspectorController* ic = static_cast<WorkerContext*>(context)->workerInspectorController();
+    ASSERT_WITH_SECURITY_IMPLICATION(context->isWorkerGlobalScope());
+    WorkerInspectorController* ic = static_cast<WorkerGlobalScope*>(context)->workerInspectorController();
     ic->restoreInspectorStateFromCookie(savedState);
     ic->resume();
 }
 
 void WebSharedWorkerImpl::reattachDevTools(const WebString& savedState)
 {
     workerThread()->runLoop().postTaskForMode(createCallbackTask(reconnectToWorkerContextInspectorTask, String(savedState)), WorkerDebuggerAgent::debuggerTaskMode);
 }
 
 static void disconnectFromWorkerContextInspectorTask(ScriptExecutionContext* context, bool)
 {
-    ASSERT_WITH_SECURITY_IMPLICATION(context->isWorkerContext());
-    static_cast<WorkerContext*>(context)->workerInspectorController()->disconnectFrontend();
+    ASSERT_WITH_SECURITY_IMPLICATION(context->isWorkerGlobalScope());
+    static_cast<WorkerGlobalScope*>(context)->workerInspectorController()->disconnectFrontend();
 }
 
 void WebSharedWorkerImpl::detachDevTools()
 {
     workerThread()->runLoop().postTaskForMode(createCallbackTask(disconnectFromWorkerContextInspectorTask, true), WorkerDebuggerAgent::debuggerTaskMode);
 }
 
 static void dispatchOnInspectorBackendTask(ScriptExecutionContext* context, const String& message)
 {
-    ASSERT_WITH_SECURITY_IMPLICATION(context->isWorkerContext());
-    static_cast<WorkerContext*>(context)->workerInspectorController()->dispatchMessageFromFrontend(message);
+    ASSERT_WITH_SECURITY_IMPLICATION(context->isWorkerGlobalScope());
+    static_cast<WorkerGlobalScope*>(context)->workerInspectorController()->dispatchMessageFromFrontend(message);
 }
 
 void WebSharedWorkerImpl::dispatchDevToolsMessage(const WebString& message)
 {
     workerThread()->runLoop().postTaskForMode(createCallbackTask(dispatchOnInspectorBackendTask, String(message)), WorkerDebuggerAgent::debuggerTaskMode);
     WorkerDebuggerAgent::interruptAndDispatchInspectorCommands(workerThread());
 }
 
 WebSharedWorker* WebSharedWorker::create(WebSharedWorkerClient* client)
 {
     return new WebSharedWorkerImpl(client);
 }
 
 } // namespace WebKit