Patch 3 in the series.

WebKit/chromium/src/WorkerFileSystemCallbacksBridge.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 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "WorkerFileSystemCallbacksBridge.h"
 
 #if ENABLE(FILE_SYSTEM) && ENABLE(WORKERS)
 
+#include "BlobData.h"
 #include "CrossThreadTask.h"
 #include "KURL.h"
 #include "WebCommonWorkerClient.h"
-#include "WebFileSystemCallbacks.h"
+#include "WebFileSystemCallbacksImpl.h"
 #include "WebFileSystemEntry.h"
 #include "WebWorkerBase.h"
 #include "WorkerContext.h"
 #include "WorkerLoaderProxy.h"
 #include "WorkerScriptController.h"
 #include "WorkerThread.h"
 #include <public/WebFileInfo.h>
 #include <public/WebString.h>
 #include <public/WebURL.h>
 #include <wtf/MainThread.h>
@@ skipping 67 matching lines @@
         m_bridge->didSucceedOnMainThread(m_mode);
         delete this;
     }
 
     virtual void didReadMetadata(const WebFileInfo& info)
     {
         m_bridge->didReadMetadataOnMainThread(info, m_mode);
         delete this;
     }
 
+    virtual void didCreateSnapshotFile(const WebFileInfo& info)
+    {
+        // It's important to create a BlobDataHandle that refers to the platform file path prior
+        // to return from this method so the underlying file will not be deleted.
+        OwnPtr<BlobData> blobData = BlobData::create();
+        blobData->appendFile(info.platformPath);
+        RefPtr<BlobDataHandle> snapshotBlob = BlobDataHandle::create(blobData.release(), info.length);
+        m_bridge->didCreateSnapshotFileOnMainThread(info, m_mode, snapshotBlob);
+        delete this;
+    }
+
     virtual void didReadDirectory(const WebVector<WebFileSystemEntry>& entries, bool hasMore)
     {
         m_bridge->didReadDirectoryOnMainThread(entries, hasMore, m_mode);
         delete this;
     }
 
 private:
     MainThreadFileSystemCallbacks(PassRefPtr<WorkerFileSystemCallbacksBridge> bridge, const String& mode)
         : m_bridge(bridge)
         , m_mode(mode)
@@ skipping 145 matching lines @@
 
 void WorkerFileSystemCallbacksBridge::postReadDirectoryToMainThread(WebFileSystem* fileSystem, const KURL& path, const String& mode)
 {
     ASSERT(fileSystem);
     dispatchTaskToMainThread(
         createCallbackTask(&readDirectoryOnMainThread,
                            AllowCrossThreadAccess(fileSystem), path,
                            this, mode));
 }
 
-void WorkerFileSystemCallbacksBridge::postCreateSnapshotFileToMainThread(WebFileSystem* fileSystem, const KURL& internalBlobURL, const KURL& path, const String& mode)
+void WorkerFileSystemCallbacksBridge::postCreateSnapshotFileToMainThread(WebFileSystem* fileSystem, const KURL& path, const String& mode)
 {
     ASSERT(fileSystem);
     dispatchTaskToMainThread(
         createCallbackTask(&createSnapshotFileOnMainThread,
                            AllowCrossThreadAccess(fileSystem),
-                           internalBlobURL, path, this, mode));
+                           path, this, mode));
 }
 
 void WorkerFileSystemCallbacksBridge::openFileSystemOnMainThread(ScriptExecutionContext*, WebCommonWorkerClient* commonClient, WebFileSystem::Type type, long long size, bool create, PassRefPtr<WorkerFileSystemCallbacksBridge> bridge, const String& mode)
 {
     if (!commonClient)
         bridge->didFailOnMainThread(WebFileErrorAbort, mode);
     else {
         commonClient->openFileSystem(type, size, create, MainThreadFileSystemCallbacks::createLeakedPtr(bridge, mode));
     }
 }
@@ skipping 41 matching lines @@
 void WorkerFileSystemCallbacksBridge::directoryExistsOnMainThread(WebCore::ScriptExecutionContext*, WebFileSystem* fileSystem, const KURL& path, PassRefPtr<WorkerFileSystemCallbacksBridge> bridge, const String& mode)
 {
     fileSystem->directoryExists(path, MainThreadFileSystemCallbacks::createLeakedPtr(bridge, mode));
 }
 
 void WorkerFileSystemCallbacksBridge::readDirectoryOnMainThread(WebCore::ScriptExecutionContext*, WebFileSystem* fileSystem, const KURL& path, PassRefPtr<WorkerFileSystemCallbacksBridge> bridge, const String& mode)
 {
     fileSystem->readDirectory(path, MainThreadFileSystemCallbacks::createLeakedPtr(bridge, mode));
 }
 
-void WorkerFileSystemCallbacksBridge::createSnapshotFileOnMainThread(WebCore::ScriptExecutionContext*, WebFileSystem* fileSystem, const KURL& internalBlobURL, const KURL& path, PassRefPtr<WorkerFileSystemCallbacksBridge> bridge, const String& mode)
+void WorkerFileSystemCallbacksBridge::createSnapshotFileOnMainThread(WebCore::ScriptExecutionContext*, WebFileSystem* fileSystem, const KURL& path, PassRefPtr<WorkerFileSystemCallbacksBridge> bridge, const String& mode)
 {
-    fileSystem->createSnapshotFileAndReadMetadata(internalBlobURL, path, MainThreadFileSystemCallbacks::createLeakedPtr(bridge, mode));
+    fileSystem->createSnapshotFileAndReadMetadata(path, MainThreadFileSystemCallbacks::createLeakedPtr(bridge, mode));
 }
 
 void WorkerFileSystemCallbacksBridge::didFailOnMainThread(WebFileError error, const String& mode)
 {
     mayPostTaskToWorker(createCallbackTask(&didFailOnWorkerThread, this, error), mode);
 }
 
 void WorkerFileSystemCallbacksBridge::didOpenFileSystemOnMainThread(const String& name, const KURL& rootURL, const String& mode)
 {
     mayPostTaskToWorker(createCallbackTask(&didOpenFileSystemOnWorkerThread,
                                            this, name, rootURL), mode);
 }
 
 void WorkerFileSystemCallbacksBridge::didSucceedOnMainThread(const String& mode)
 {
     mayPostTaskToWorker(createCallbackTask(&didSucceedOnWorkerThread, this), mode);
 }
 
 void WorkerFileSystemCallbacksBridge::didReadMetadataOnMainThread(const WebFileInfo& info, const String& mode)
 {
     mayPostTaskToWorker(createCallbackTask(&didReadMetadataOnWorkerThread, this, info), mode);
 }
 
+void WorkerFileSystemCallbacksBridge::didCreateSnapshotFileOnMainThread(const WebFileInfo& info, const String& mode, PassRefPtr<BlobDataHandle> snapshotBlob)
+{
+    mayPostTaskToWorker(createCallbackTask(&didCreateSnapshotFileOnWorkerThread, this, info, snapshotBlob), mode);
+}
+
 void WorkerFileSystemCallbacksBridge::didReadDirectoryOnMainThread(const WebVector<WebFileSystemEntry>& entries, bool hasMore, const String& mode)
 {
     mayPostTaskToWorker(
         createCallbackTask(&didReadDirectoryOnWorkerThread,
                            this, entries, hasMore), mode);
 }
 
-WorkerFileSystemCallbacksBridge::WorkerFileSystemCallbacksBridge(WebCore::WorkerLoaderProxy* workerLoaderProxy, ScriptExecutionContext* scriptExecutionContext, WebFileSystemCallbacks* callbacks)
+WorkerFileSystemCallbacksBridge::WorkerFileSystemCallbacksBridge(WebCore::WorkerLoaderProxy* workerLoaderProxy, ScriptExecutionContext* scriptExecutionContext, WebFileSystemCallbacksImpl* callbacks)
     : m_workerLoaderProxy(workerLoaderProxy)
     , m_workerContext(scriptExecutionContext)
     , m_workerContextObserver(WorkerFileSystemContextObserver::create(static_cast<WorkerContext*>(m_workerContext), this).leakPtr())
     , m_callbacksOnWorkerThread(callbacks)
 {
     ASSERT(m_workerContext->isContextThread());
 }
 
 WorkerFileSystemCallbacksBridge::~WorkerFileSystemCallbacksBridge()
 {
@@ skipping 13 matching lines @@
 void WorkerFileSystemCallbacksBridge::didSucceedOnWorkerThread(ScriptExecutionContext*, PassRefPtr<WorkerFileSystemCallbacksBridge> bridge)
 {
     bridge->m_callbacksOnWorkerThread->didSucceed();
 }
 
 void WorkerFileSystemCallbacksBridge::didReadMetadataOnWorkerThread(ScriptExecutionContext*, PassRefPtr<WorkerFileSystemCallbacksBridge> bridge, const WebFileInfo& info)
 {
     bridge->m_callbacksOnWorkerThread->didReadMetadata(info);
 }
 
+void WorkerFileSystemCallbacksBridge::didCreateSnapshotFileOnWorkerThread(ScriptExecutionContext*, PassRefPtr<WorkerFileSystemCallbacksBridge> bridge, const WebFileInfo& info, PassRefPtr<BlobDataHandle> snapshotBlob)
+{
+    bridge->m_callbacksOnWorkerThread->didCreateSnapshotFile(info, snapshotBlob);
+}
+
 void WorkerFileSystemCallbacksBridge::didReadDirectoryOnWorkerThread(ScriptExecutionContext*, PassRefPtr<WorkerFileSystemCallbacksBridge> bridge, const WebVector<WebFileSystemEntry>& entries, bool hasMore)
 {
     bridge->m_callbacksOnWorkerThread->didReadDirectory(entries, hasMore);
 }
 
 
 void WorkerFileSystemCallbacksBridge::runTaskOnMainThread(WebCore::ScriptExecutionContext* scriptExecutionContext, PassRefPtr<WorkerFileSystemCallbacksBridge> bridge, PassOwnPtr<WebCore::ScriptExecutionContext::Task> taskToRun)
 {
     ASSERT(isMainThread());
     taskToRun->performTask(scriptExecutionContext);
@@ skipping 25 matching lines @@
     ASSERT(isMainThread());
 
     MutexLocker locker(m_loaderProxyMutex);
     if (m_workerLoaderProxy)
         m_workerLoaderProxy->postTaskForModeToWorkerContext(createCallbackTask(&runTaskOnWorkerThread, this, task), mode);
 }
 
 } // namespace WebCore
 
 #endif // ENABLE(FILE_SYSTEM)