Changeset 68222 in webkit
- Timestamp:
- Sep 23, 2010 5:46:01 PM (14 years ago)
- Location:
- trunk
- Files:
-
- 2 added
- 24 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/WebCore/ChangeLog
r68221 r68222 1 2010-09-23 Kinuko Yasuda <kinuko@chromium.org> 2 3 Reviewed by David Levin. 4 5 Add Worker support for FileSystem API 6 https://bugs.webkit.org/show_bug.cgi?id=45808 7 8 Exposed requestFileSystem and Flags constructor on worker contexts. 9 10 Also changed how to get the base path for Web file systems (in 11 non-chromium ports) so that it works for workers too. 12 This patch assumes each port calls 13 LocalFileSystem::initializeLocalFileSystem() in its initialization 14 phase. 15 16 No new tests; tests will be added when we have complete implementation. 17 18 * bindings/generic/RuntimeEnabledFeatures.cpp: 19 (WebCore::RuntimeEnabledFeatures::fileSystemEnabled): Changed to 20 reflect AsyncFileSystem::isAvailable 21 * bindings/generic/RuntimeEnabledFeatures.h: Moved the implementation 22 of fileSystemEnabled to .cpp. 23 * fileapi/LocalFileSystem.cpp: 24 (WebCore::LocalFileSystem::initializeLocalFileSystem): Added. 25 (WebCore::LocalFileSystem::localFileSystem): Added. 26 (WebCore::LocalFileSystem::fileSystemBasePath): Added. 27 * fileapi/LocalFileSystem.h: 28 (WebCore::LocalFileSystem::~LocalFileSystem): Removed. (As now it's 29 going to be used as a singleton.) 30 * page/DOMWindow.cpp: 31 (WebCore::DOMWindow::requestFileSystem): Changed to use a singleton 32 instance of LocalFileSystem. 33 * page/SecurityOrigin.h: 34 (WebCore::SecurityOrigin::canAccessFileSystem): Added. 35 * page/Settings.cpp: Removed fileSystemRootPath method. 36 * page/Settings.h: Removed fileSystemRootPath method. 37 * platform/AsyncFileSystem.cpp: 38 (WebCore::AsyncFileSystem::isAvailable): Added. 39 * workers/WorkerContext.cpp: 40 (WebCore::WorkerContext::requestFileSystem): Added to expose 41 requestFileSystem method in worker contexts. 42 (WebCore::WorkerContext::Observer): Added. 43 (WebCore::WorkerContext::registerObserver): Added. 44 (WebCore::WorkerContext::unregisterObserver): Added. 45 (WebCore::WorkerContext::notifyObserversOfStop): Added. 46 * workers/WorkerContext.h: 47 * workers/WorkerContext.idl: 48 * workers/WorkerThread.cpp: 49 (WebCore::WorkerThreadShutdownStartTask::performTask): Modified to 50 call workerContext->notifyObserversOfStop to notify worker observers 51 of the worker thread termination. 52 1 53 2010-09-23 Matthew Delaney <mdelaney@apple.com> 2 54 -
trunk/WebCore/bindings/generic/RuntimeEnabledFeatures.cpp
r66570 r68222 37 37 #include "WebSocket.h" 38 38 39 #if ENABLE(FILE_SYSTEM) 40 #include "AsyncFileSystem.h" 41 #endif 42 39 43 namespace WebCore { 40 44 … … 58 62 #if ENABLE(FILE_SYSTEM) 59 63 bool RuntimeEnabledFeatures::isFileSystemEnabled = false; 64 65 bool RuntimeEnabledFeatures::fileSystemEnabled() 66 { 67 return isFileSystemEnabled && AsyncFileSystem::isAvailable(); 68 } 60 69 #endif 61 70 -
trunk/WebCore/bindings/generic/RuntimeEnabledFeatures.h
r66802 r68222 149 149 150 150 #if ENABLE(FILE_SYSTEM) 151 static bool fileSystemEnabled() { return isFileSystemEnabled; }151 static bool fileSystemEnabled(); 152 152 static void setFileSystemEnabled(bool isEnabled) { isFileSystemEnabled = isEnabled; } 153 153 static bool requestFileSystemEnabled() { return isFileSystemEnabled; } -
trunk/WebCore/fileapi/LocalFileSystem.cpp
r66586 r68222 51 51 namespace WebCore { 52 52 53 PassRefPtr<LocalFileSystem> LocalFileSystem::create(const String& basePath) 53 LocalFileSystem* LocalFileSystem::s_instance = 0; 54 55 void LocalFileSystem::initializeLocalFileSystem(const String& basePath) 54 56 { 55 return adoptRef(new LocalFileSystem(basePath)); 57 // FIXME: Should initialize the quota settings as well. 58 ASSERT(isMainThread()); 59 ASSERT(!s_instance); 60 if (s_instance) 61 return; 62 63 OwnPtr<LocalFileSystem> localFileSystem = adoptPtr(new LocalFileSystem(basePath)); 64 s_instance = localFileSystem.leakPtr(); 65 } 66 67 LocalFileSystem& LocalFileSystem::localFileSystem() 68 { 69 // initializeLocalFileSystem must be called prior calling this. 70 ASSERT(s_instance); 71 return *s_instance; 72 } 73 74 String LocalFileSystem::fileSystemBasePath() const 75 { 76 return m_basePath; 56 77 } 57 78 … … 69 90 70 91 // AsyncFileSystem::openFileSystem calls callbacks synchronously, so the method needs to be called asynchronously. 71 context->postTask(createCallbackTask(&openFileSystem, m_basePath, context->securityOrigin()->databaseIdentifier(), type, new FileSystemCallbacks(successCallback, errorCallback, context)));92 context->postTask(createCallbackTask(&openFileSystem, fileSystemBasePath(), context->securityOrigin()->databaseIdentifier(), type, new FileSystemCallbacks(successCallback, errorCallback, context))); 72 93 } 73 94 -
trunk/WebCore/fileapi/LocalFileSystem.h
r66586 r68222 45 45 class ScriptExecutionContext; 46 46 47 class LocalFileSystem : public RefCounted<LocalFileSystem> { 47 // Keeps per-process information and provides an entry point to open a file system. 48 class LocalFileSystem : public Noncopyable { 48 49 public: 49 static PassRefPtr<LocalFileSystem> create(const String& basePath); 50 virtual ~LocalFileSystem() { } 50 // Returns a per-process instance of LocalFileSystem. 51 // Note that LocalFileSystem::initializeLocalFileSystem must be called before 52 // calling this one. 53 static LocalFileSystem& localFileSystem(); 51 54 52 55 void requestFileSystem(ScriptExecutionContext*, AsyncFileSystem::Type, long long size, PassRefPtr<FileSystemCallback>, PassRefPtr<ErrorCallback>); 53 56 54 protected: 57 #if !PLATFORM(CHROMIUM) 58 // This call is not thread-safe; must be called before any worker threads are created. 59 void initializeLocalFileSystem(const String&); 60 61 String fileSystemBasePath() const; 62 #endif 63 64 private: 55 65 LocalFileSystem(const String& basePath) 56 66 : m_basePath(basePath) … … 58 68 } 59 69 60 String m_basePath; 70 static LocalFileSystem* s_instance; 71 72 // An inner class that enforces thread-safe string access. 73 class SystemBasePath { 74 public: 75 explicit SystemBasePath(const String& path) : m_value(path) { } 76 operator String() const 77 { 78 return m_value.threadsafeCopy(); 79 } 80 private: 81 String m_value; 82 }; 83 84 SystemBasePath m_basePath; 61 85 }; 62 86 -
trunk/WebCore/page/DOMWindow.cpp
r67762 r68222 728 728 return; 729 729 730 if (!m_localFileSystem) { 731 // FIXME: See if access is allowed. 732 733 Page* page = document->page(); 734 if (!page) { 735 DOMFileSystem::scheduleCallback(document, errorCallback, FileError::create(INVALID_STATE_ERR)); 736 return; 737 } 738 739 // FIXME: Get the quota settings as well. 740 String path = page->settings()->fileSystemRootPath(); 741 m_localFileSystem = LocalFileSystem::create(path); 742 } 743 744 m_localFileSystem->requestFileSystem(document, static_cast<AsyncFileSystem::Type>(type), size, successCallback, errorCallback); 745 } 746 747 COMPILE_ASSERT(int(DOMWindow::TEMPORARY) == int(AsyncFileSystem::Temporary), enum_mismatch); 748 COMPILE_ASSERT(int(DOMWindow::PERSISTENT) == int(AsyncFileSystem::Persistent), enum_mismatch); 730 if (!AsyncFileSystem::isAvailable() || !document->securityOrigin()->canAccessFileSystem()) { 731 DOMFileSystem::scheduleCallback(document, errorCallback, FileError::create(SECURITY_ERR)); 732 return; 733 } 734 735 LocalFileSystem::localFileSystem().requestFileSystem(document, static_cast<AsyncFileSystem::Type>(type), size, successCallback, errorCallback); 736 } 737 738 COMPILE_ASSERT(static_cast<int>(DOMWindow::TEMPORARY) == static_cast<int>(AsyncFileSystem::Temporary), enum_mismatch); 739 COMPILE_ASSERT(static_cast<int>(DOMWindow::PERSISTENT) == static_cast<int>(AsyncFileSystem::Persistent), enum_mismatch); 749 740 750 741 #endif -
trunk/WebCore/page/DOMWindow.h
r66802 r68222 59 59 class IDBFactory; 60 60 class InspectorTimelineAgent; 61 class LocalFileSystem;62 61 class Location; 63 62 class StyleMedia; … … 445 444 mutable RefPtr<IDBFactory> m_idbFactory; 446 445 #endif 447 #if ENABLE(FILE_SYSTEM)448 RefPtr<LocalFileSystem> m_localFileSystem;449 #endif450 446 451 447 EventTargetData m_eventTargetData; -
trunk/WebCore/page/SecurityOrigin.h
r67316 r68222 122 122 bool canAccessCookies() const { return !isUnique(); } 123 123 bool canAccessPasswordManager() const { return !isUnique(); } 124 bool canAccessFileSystem() const { return !isUnique(); } 124 125 125 126 // Technically, we should always allow access to sessionStorage, but we -
trunk/WebCore/page/Settings.cpp
r68166 r68222 499 499 } 500 500 501 void Settings::setFileSystemRootPath(const String& path)502 {503 m_fileSystemRootPath = path;504 }505 506 501 void Settings::setApplicationChromeMode(bool mode) 507 502 { -
trunk/WebCore/page/Settings.h
r68188 r68222 242 242 const String& localStorageDatabasePath() const { return m_localStorageDatabasePath; } 243 243 244 void setFileSystemRootPath(const String&);245 const String& fileSystemRootPath() const { return m_fileSystemRootPath; }246 247 244 void setApplicationChromeMode(bool); 248 245 bool inApplicationChromeMode() const { return m_inApplicationChromeMode; } … … 340 337 String m_ftpDirectoryTemplatePath; 341 338 String m_localStorageDatabasePath; 342 String m_fileSystemRootPath;343 339 KURL m_userStyleSheetLocation; 344 340 AtomicString m_standardFontFamily; -
trunk/WebCore/platform/AsyncFileSystem.cpp
r66255 r68222 36 36 #include "AsyncFileSystemCallbacks.h" 37 37 #include "FileSystem.h" 38 #include "NotImplemented.h" 38 39 39 40 namespace WebCore { 40 41 42 #if !PLATFORM(CHROMIUM) 43 bool AsyncFileSystem::isAvailable() 44 { 45 notImplemented(); 46 return false; 47 } 48 41 49 PassOwnPtr<AsyncFileSystem> AsyncFileSystem::create(const String&) 42 50 { 43 // FIXME: return default AsyncFileSystem implementation.51 notImplemented(); 44 52 return 0; 45 53 } … … 63 71 callbacks->didOpenFileSystem(name, AsyncFileSystem::create(rootPath)); 64 72 } 73 #endif 65 74 66 75 // Default implementation. -
trunk/WebCore/platform/AsyncFileSystem.h
r68180 r68222 57 57 virtual void stop() { } 58 58 virtual bool hasPendingActivity() { return false; } 59 60 static bool isAvailable(); 59 61 60 62 // Creates and returns a new platform-specific AsyncFileSystem instance if the platform has its own implementation. -
trunk/WebCore/workers/WorkerContext.cpp
r66537 r68222 64 64 #endif 65 65 66 #if ENABLE(FILE_SYSTEM) 67 #include "AsyncFileSystem.h" 68 #include "DOMFileSystem.h" 69 #include "ErrorCallback.h" 70 #include "FileError.h" 71 #include "FileSystemCallback.h" 72 #include "LocalFileSystem.h" 73 #endif 74 66 75 namespace WebCore { 67 76 … … 101 110 m_notifications.clear(); 102 111 #endif 112 113 // Make sure we have no observers. 114 notifyObserversOfStop(); 115 103 116 // Notify proxy that we are going away. This can free the WorkerThread object, so do not access it after this. 104 117 thread()->workerReportingProxy().workerContextDestroyed(); … … 336 349 #endif 337 350 351 #if ENABLE(FILE_SYSTEM) 352 void WorkerContext::requestFileSystem(int type, long long size, PassRefPtr<FileSystemCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback) 353 { 354 if (!AsyncFileSystem::isAvailable() || !securityOrigin()->canAccessFileSystem()) { 355 DOMFileSystem::scheduleCallback(this, errorCallback, FileError::create(SECURITY_ERR)); 356 return; 357 } 358 359 LocalFileSystem::localFileSystem().requestFileSystem(this, static_cast<AsyncFileSystem::Type>(type), size, successCallback, errorCallback); 360 } 361 362 COMPILE_ASSERT(static_cast<int>(WorkerContext::TEMPORARY) == static_cast<int>(AsyncFileSystem::Temporary), enum_mismatch); 363 COMPILE_ASSERT(static_cast<int>(WorkerContext::PERSISTENT) == static_cast<int>(AsyncFileSystem::Persistent), enum_mismatch); 364 #endif 365 366 WorkerContext::Observer::Observer(WorkerContext* context) 367 : m_context(context) 368 { 369 ASSERT(m_context && m_context->isContextThread()); 370 m_context->registerObserver(this); 371 } 372 373 WorkerContext::Observer::~Observer() 374 { 375 if (!m_context) 376 return; 377 ASSERT(m_context->isContextThread()); 378 m_context->unregisterObserver(this); 379 } 380 381 void WorkerContext::Observer::stopObserving() 382 { 383 if (!m_context) 384 return; 385 ASSERT(m_context->isContextThread()); 386 m_context->unregisterObserver(this); 387 m_context = 0; 388 } 389 390 void WorkerContext::registerObserver(Observer* observer) 391 { 392 ASSERT(observer); 393 m_workerObservers.add(observer); 394 } 395 396 void WorkerContext::unregisterObserver(Observer* observer) 397 { 398 ASSERT(observer); 399 m_workerObservers.remove(observer); 400 } 401 402 void WorkerContext::notifyObserversOfStop() 403 { 404 HashSet<Observer*>::iterator iter = m_workerObservers.begin(); 405 while (iter != m_workerObservers.end()) { 406 WorkerContext::Observer* observer = *iter; 407 observer->stopObserving(); 408 observer->notifyStop(); 409 iter = m_workerObservers.begin(); 410 } 411 } 412 338 413 } // namespace WebCore 339 414 -
trunk/WebCore/workers/WorkerContext.h
r66537 r68222 36 36 #include "WorkerScriptController.h" 37 37 #include <wtf/Assertions.h> 38 #include <wtf/HashMap.h> 38 39 #include <wtf/OwnPtr.h> 39 40 #include <wtf/PassRefPtr.h> … … 48 49 class DatabaseCallback; 49 50 class DatabaseSync; 51 class ErrorCallback; 52 class FileSystemCallback; 50 53 class NotificationCenter; 51 54 class ScheduledAction; … … 122 125 #endif 123 126 127 #if ENABLE(FILE_SYSTEM) 128 enum FileSystemType { 129 TEMPORARY, 130 PERSISTENT, 131 }; 132 void requestFileSystem(int type, long long size, PassRefPtr<FileSystemCallback>, PassRefPtr<ErrorCallback>); 133 #endif 134 124 135 // These methods are used for GC marking. See JSWorkerContext::markChildren(MarkStack&) in 125 136 // JSWorkerContextCustom.cpp. … … 131 142 132 143 bool isClosing() { return m_closing; } 144 145 // An observer interface to be notified when the worker thread is getting stopped. 146 class Observer : public Noncopyable { 147 public: 148 Observer(WorkerContext*); 149 virtual ~Observer(); 150 virtual void notifyStop() = 0; 151 void stopObserving(); 152 private: 153 WorkerContext* m_context; 154 }; 155 friend class Observer; 156 void registerObserver(Observer*); 157 void unregisterObserver(Observer*); 158 void notifyObserversOfStop(); 133 159 134 160 protected: … … 162 188 bool m_reportingException; 163 189 EventTargetData m_eventTargetData; 190 191 HashSet<Observer*> m_workerObservers; 164 192 }; 165 193 -
trunk/WebCore/workers/WorkerContext.idl
r66537 r68222 105 105 void revokeBlobURL(in DOMString blobURL); 106 106 #endif 107 108 #if defined(ENABLE_FILE_SYSTEM) && ENABLE_FILE_SYSTEM 109 const unsigned short TEMPORARY = 0; 110 const unsigned short PERSISTENT = 1; 111 [EnabledAtRuntime] void requestFileSystem(in unsigned short type, in long long size, in [Callback, Optional] FileSystemCallback successCallback, in [Callback, Optional] ErrorCallback errorCallback); 112 113 attribute [EnabledAtRuntime=FileSystem] FlagsConstructor Flags; 114 #endif 107 115 }; 108 116 -
trunk/WebCore/workers/WorkerThread.cpp
r64384 r68222 203 203 workerContext->stopActiveDOMObjects(); 204 204 205 workerContext->notifyObserversOfStop(); 206 205 207 // Event listeners would keep DOMWrapperWorld objects alive for too long. Also, they have references to JS objects, 206 208 // which become dangling once Heap is destroyed. -
trunk/WebKit/chromium/ChangeLog
r68216 r68222 1 2010-09-23 Kinuko Yasuda <kinuko@chromium.org> 2 3 Reviewed by David Levin. 4 5 Add Worker support for FileSystem API 6 https://bugs.webkit.org/show_bug.cgi?id=45808 7 8 Added WebWorkerBase::openFileSystem and WebCommonWorkerClient:: 9 openFileSystem to call in to the browser via Worker stub/proxy 10 in the chromium. 11 12 Also added WorkerFileSystemCallbacksBridge class that proxies 13 requests and callbacks between from/to worker thread to/from the 14 main thread. 15 16 * public/WebCommonWorkerClient.h: 17 (WebKit::WebCommonWorkerClient::openFileSystem): Added. 18 * src/LocalFileSystemChromium.cpp: 19 (WebCore::LocalFileSystem::localFileSystem): Added. 20 (WebCore::LocalFileSystem::requestFileSystem): Added implementation 21 for workers. In worker case this calls WebWorkerBase::openFileSystem. 22 * src/WebWorkerBase.cpp: 23 (WebKit::WebWorkerBase::openFileSystem): Added. This is called from 24 LocalFileSystem::requestFileSystem on the worker thread and creates 25 a bridge to call WebCommonWorkerClient::openFileSystem on the main 26 thread. 27 * src/WebWorkerBase.h: 28 * src/WebWorkerClientImpl.h: 29 (WebKit::WebWorkerClientImpl::openFileSystem): Added. 30 * src/WorkerFileSystemCallbacksBridge.cpp: Added. 31 * src/WorkerFileSystemCallbacksBridge.h: Added. 32 1 33 2010-09-23 Tony Chang <tony@chromium.org> 2 34 -
trunk/WebKit/chromium/WebKit.gyp
r68141 r68222 533 533 'src/WebWorkerImpl.cpp', 534 534 'src/WebWorkerImpl.h', 535 'src/WorkerFileSystemCallbacksBridge.cpp', 536 'src/WorkerFileSystemCallbacksBridge.h', 535 537 'src/WrappedResourceRequest.h', 536 538 'src/WrappedResourceResponse.h', -
trunk/WebKit/chromium/public/WebCommonWorkerClient.h
r59555 r68222 31 31 #ifndef WebCommonWorkerClient_h 32 32 #define WebCommonWorkerClient_h 33 34 #include "WebCommon.h" 35 #include "WebFileSystem.h" 33 36 34 37 namespace WebKit { … … 84 87 virtual bool allowDatabase(WebFrame*, const WebString& name, const WebString& displayName, unsigned long estimatedSize) = 0; 85 88 89 // Called on the main webkit thread before opening a file system. 90 virtual void openFileSystem(WebFileSystem::Type, long long size, WebFileSystemCallbacks*) 91 { 92 WEBKIT_ASSERT_NOT_REACHED(); 93 } 94 86 95 protected: 87 96 ~WebCommonWorkerClient() { } -
trunk/WebKit/chromium/src/AsyncFileSystemChromium.cpp
r68180 r68222 45 45 46 46 namespace WebCore { 47 48 bool AsyncFileSystem::isAvailable() 49 { 50 return true; 51 } 47 52 48 53 AsyncFileSystemChromium::AsyncFileSystemChromium(const String& rootPath) -
trunk/WebKit/chromium/src/LocalFileSystemChromium.cpp
r66280 r68222 43 43 #include "WebFrameClient.h" 44 44 #include "WebFrameImpl.h" 45 #include "WebWorkerImpl.h" 46 #include "WorkerContext.h" 47 #include "WorkerThread.h" 48 #include <wtf/Threading.h> 45 49 46 50 using namespace WebKit; … … 48 52 namespace WebCore { 49 53 50 PassRefPtr<LocalFileSystem> LocalFileSystem::create(const String& path)54 LocalFileSystem& LocalFileSystem::localFileSystem() 51 55 { 52 return adoptRef(new LocalFileSystem(path)); 56 AtomicallyInitializedStatic(LocalFileSystem*, localFileSystem = new LocalFileSystem("")); 57 return *localFileSystem; 53 58 } 54 59 … … 61 66 webFrame->client()->openFileSystem(webFrame, static_cast<WebFileSystem::Type>(type), size, new WebFileSystemCallbacksImpl(new FileSystemCallbacks(successCallback, errorCallback, context))); 62 67 } else { 63 // FIXME: Add implementation for workers. 68 WorkerContext* workerContext = static_cast<WorkerContext*>(context); 69 WorkerLoaderProxy* workerLoaderProxy = &workerContext->thread()->workerLoaderProxy(); 70 WebWorkerBase* webWorker = static_cast<WebWorkerBase*>(workerLoaderProxy); 71 webWorker->openFileSystem(static_cast<WebFileSystem::Type>(type), size, new WebFileSystemCallbacksImpl(new FileSystemCallbacks(successCallback, errorCallback, context))); 64 72 } 65 73 } -
trunk/WebKit/chromium/src/WebWorkerBase.cpp
r65021 r68222 38 38 39 39 #include "WebDataSourceImpl.h" 40 #include "WebFileError.h" 40 41 #include "WebFrameClient.h" 41 42 #include "WebFrameImpl.h" … … 46 47 #include "WebWorkerClient.h" 47 48 49 #include "WorkerContext.h" 50 #include "WorkerFileSystemCallbacksBridge.h" 48 51 #include "WorkerScriptController.h" 49 52 #include "WorkerThread.h" … … 57 60 58 61 static const char allowDatabaseMode[] = "allowDatabaseMode"; 62 static const char openFileSystemMode[] = "openFileSystemMode"; 59 63 60 64 namespace { … … 115 119 WTF::String m_mode; 116 120 }; 121 117 122 } 118 123 … … 232 237 } 233 238 239 void WebWorkerBase::openFileSystem(WebFileSystem::Type type, long long size, WebFileSystemCallbacks* callbacks) 240 { 241 WorkerRunLoop& runLoop = m_workerThread->runLoop(); 242 WorkerScriptController* controller = WorkerScriptController::controllerForContext(); 243 WorkerContext* workerContext = controller->workerContext(); 244 245 RefPtr<WorkerFileSystemCallbacksBridge> bridge = WorkerFileSystemCallbacksBridge::create(this, workerContext, callbacks); 246 bridge->postOpenFileSystemToMainThread(commonClient(), type, size, openFileSystemMode); 247 } 248 234 249 // WorkerObjectProxy ----------------------------------------------------------- 235 250 -
trunk/WebKit/chromium/src/WebWorkerBase.h
r65021 r68222 92 92 virtual bool allowDatabase(WebFrame*, const WebString& name, const WebString& displayName, unsigned long estimatedSize); 93 93 94 // Requests to open a file system for this worker. (Note that this is not the implementation for WebFrameClient::openFileSystem.) 95 void openFileSystem(WebFileSystem::Type, long long size, WebFileSystemCallbacks*); 96 94 97 // Executes the given task on the main thread. 95 98 static void dispatchTaskToMainThread(PassOwnPtr<WebCore::ScriptExecutionContext::Task>); -
trunk/WebKit/chromium/src/WebWorkerClientImpl.h
r65021 r68222 34 34 #if ENABLE(WORKERS) 35 35 36 #include "WebFileSystem.h" 36 37 #include "WebWorkerClient.h" 37 38 38 #include "WorkerContextProxy.h" 39 39 #include <wtf/PassOwnPtr.h> … … 100 100 return true; 101 101 } 102 virtual void openFileSystem(WebFrame*, WebFileSystem::Type, long long size, WebFileSystemCallbacks*) 103 { 104 ASSERT_NOT_REACHED(); 105 } 102 106 103 107 private:
Note: See TracChangeset
for help on using the changeset viewer.