Rename WorkerContext to WorkerGlobalScope

Source/WebKit/chromium/src/LocalFileSystemChromium.cpp

 /*
  * Copyright (C) 2010, 2012 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 23 matching lines @@
 #include "WebFileSystemCallbacksImpl.h"
 #include "WebFrameClient.h"
 #include "WebFrameImpl.h"
 #include "WebPermissionClient.h"
 #include "WebViewImpl.h"
 #include "WebWorkerBase.h"
 #include "WorkerAllowMainThreadBridgeBase.h"
 #include "WorkerFileSystemCallbacksBridge.h"
 #include "core/dom/CrossThreadTask.h"
 #include "core/dom/Document.h"
-#include "core/workers/WorkerContext.h"
+#include "core/workers/WorkerGlobalScope.h"
 #include "core/workers/WorkerThread.h"
 #include "modules/filesystem/ErrorCallback.h"
 #include "modules/filesystem/FileSystemCallback.h"
 #include "modules/filesystem/FileSystemCallbacks.h"
 #include "modules/filesystem/FileSystemType.h"
 #include "public/platform/WebFileError.h"
 #include "public/platform/WebFileSystem.h"
 #include "public/platform/WebFileSystemType.h"
 #include <wtf/text/WTFString.h>
 #include <wtf/Threading.h>
@@ skipping 15 matching lines @@
     CreateIfNotPresent
 };
 
 static const char allowFileSystemMode[] = "allowFileSystemMode";
 static const char openFileSystemMode[] = "openFileSystemMode";
 
 // This class is used to route the result of the WebWorkerBase::allowFileSystem
 // call back to the worker context.
 class AllowFileSystemMainThreadBridge : public WorkerAllowMainThreadBridgeBase {
 public:
-    static PassRefPtr<AllowFileSystemMainThreadBridge> create(WebCore::WorkerContext* workerContext, WebWorkerBase* webWorkerBase, const String& mode)
+    static PassRefPtr<AllowFileSystemMainThreadBridge> create(WebCore::WorkerGlobalScope* workerGlobalScope, WebWorkerBase* webWorkerBase, const String& mode)
     {
-        return adoptRef(new AllowFileSystemMainThreadBridge(workerContext, webWorkerBase, mode));
+        return adoptRef(new AllowFileSystemMainThreadBridge(workerGlobalScope, webWorkerBase, mode));
     }
 
 private:
-    AllowFileSystemMainThreadBridge(WebCore::WorkerContext* workerContext, WebWorkerBase* webWorkerBase, const String& mode)
-        : WorkerAllowMainThreadBridgeBase(workerContext, webWorkerBase)
+    AllowFileSystemMainThreadBridge(WebCore::WorkerGlobalScope* workerGlobalScope, WebWorkerBase* webWorkerBase, const String& mode)
+        : WorkerAllowMainThreadBridgeBase(workerGlobalScope, webWorkerBase)
     {
         postTaskToMainThread(adoptPtr(new AllowParams(mode)));
     }
 
     virtual bool allowOnMainThread(WebCommonWorkerClient* commonClient, AllowParams*)
     {
         ASSERT(isMainThread());
         return commonClient->allowFileSystem();
     }
 };
 
 bool allowFileSystemForWorker()
 {
     WorkerScriptController* controller = WorkerScriptController::controllerForContext();
-    WorkerContext* workerContext = controller->workerContext();
-    WebCore::WorkerThread* workerThread = workerContext->thread();
+    WorkerGlobalScope* workerGlobalScope = controller->workerGlobalScope();
+    WebCore::WorkerThread* workerThread = workerGlobalScope->thread();
     WorkerRunLoop& runLoop = workerThread->runLoop();
     WebCore::WorkerLoaderProxy* workerLoaderProxy = &workerThread->workerLoaderProxy();
 
     // Create a unique mode just for this synchronous call.
     String mode = allowFileSystemMode;
     mode.append(String::number(runLoop.createUniqueId()));
 
-    RefPtr<AllowFileSystemMainThreadBridge> bridge = AllowFileSystemMainThreadBridge::create(workerContext, workerLoaderProxy->toWebWorkerBase(), mode);
+    RefPtr<AllowFileSystemMainThreadBridge> bridge = AllowFileSystemMainThreadBridge::create(workerGlobalScope, workerLoaderProxy->toWebWorkerBase(), mode);
 
     // Either the bridge returns, or the queue gets terminated.
-    if (runLoop.runInMode(workerContext, mode) == MessageQueueTerminated) {
+    if (runLoop.runInMode(workerGlobalScope, mode) == MessageQueueTerminated) {
         bridge->cancel();
         return false;
     }
 
     return bridge->result();
 }
 
 void openFileSystemForWorker(WebCommonWorkerClient* commonClient, WebFileSystemType type, long long size, bool create, WebFileSystemCallbacksImpl* callbacks, FileSystemSynchronousType synchronousType)
 {
     WorkerScriptController* controller = WorkerScriptController::controllerForContext();
-    WorkerContext* workerContext = controller->workerContext();
-    WebCore::WorkerThread* workerThread = workerContext->thread();
+    WorkerGlobalScope* workerGlobalScope = controller->workerGlobalScope();
+    WebCore::WorkerThread* workerThread = workerGlobalScope->thread();
     WorkerRunLoop& runLoop = workerThread->runLoop();
     WebCore::WorkerLoaderProxy* workerLoaderProxy =  &workerThread->workerLoaderProxy();
 
     // Create a unique mode for this openFileSystem call.
     String mode = openFileSystemMode;
     mode.append(String::number(runLoop.createUniqueId()));
 
-    RefPtr<WorkerFileSystemCallbacksBridge> bridge = WorkerFileSystemCallbacksBridge::create(workerLoaderProxy, workerContext, callbacks);
+    RefPtr<WorkerFileSystemCallbacksBridge> bridge = WorkerFileSystemCallbacksBridge::create(workerLoaderProxy, workerGlobalScope, callbacks);
     bridge->postOpenFileSystemToMainThread(commonClient, type, size, create, mode);
 
     if (synchronousType == SynchronousFileSystem) {
-        if (runLoop.runInMode(workerContext, mode) == MessageQueueTerminated)
+        if (runLoop.runInMode(workerGlobalScope, mode) == MessageQueueTerminated)
             bridge->stop();
     }
 }
 
 } // namespace
 
 static void openFileSystemNotAllowed(ScriptExecutionContext*, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
 {
     callbacks->didFail(WebKit::WebFileErrorAbort);
 }
 
 static void deleteFileSystemNotAllowed(ScriptExecutionContext*, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
 {
     callbacks->didFail(WebKit::WebFileErrorAbort);
 }
 
 static void openFileSystemHelper(ScriptExecutionContext* context, FileSystemType type, PassOwnPtr<AsyncFileSystemCallbacks> callbacks, FileSystemSynchronousType synchronousType, long long size, CreationFlag create)
 {
     bool allowed = true;
     ASSERT(context);
     if (context->isDocument()) {
         Document* document = static_cast<Document*>(context);
         WebFrameImpl* webFrame = WebFrameImpl::fromFrame(document->frame());
         WebKit::WebViewImpl* webView = webFrame->viewImpl();
         if (webView->permissionClient() && !webView->permissionClient()->allowFileSystem(webFrame))
             allowed = false;
         else
             webFrame->client()->openFileSystem(webFrame, static_cast<WebFileSystemType>(type), size, create == CreateIfNotPresent, new WebFileSystemCallbacksImpl(callbacks));
     } else {
-        WorkerContext* workerContext = static_cast<WorkerContext*>(context);
-        WebWorkerBase* webWorker = static_cast<WebWorkerBase*>(workerContext->thread()->workerLoaderProxy().toWebWorkerBase());
+        WorkerGlobalScope* workerGlobalScope = static_cast<WorkerGlobalScope*>(context);
+        WebWorkerBase* webWorker = static_cast<WebWorkerBase*>(workerGlobalScope->thread()->workerLoaderProxy().toWebWorkerBase());
         if (!allowFileSystemForWorker())
             allowed = false;
         else
             openFileSystemForWorker(webWorker->commonClient(), static_cast<WebFileSystemType>(type), size, create == CreateIfNotPresent, new WebFileSystemCallbacksImpl(callbacks, context, synchronousType), synchronousType);
     }
 
     if (!allowed) {
         // The tasks are expected to be called asynchronously.
         context->postTask(createCallbackTask(&openFileSystemNotAllowed, callbacks));
     }
@@ skipping 19 matching lines @@
     WebKit::WebViewImpl* webView = webFrame->viewImpl();
     if (webView->permissionClient() && !webView->permissionClient()->allowFileSystem(webFrame)) {
         context->postTask(createCallbackTask(&deleteFileSystemNotAllowed, callbacks));
         return;
     }
 
     webFrame->client()->deleteFileSystem(webFrame, static_cast<WebFileSystemType>(type), new WebFileSystemCallbacksImpl(callbacks));
 }
 
 } // namespace WebCore