Fix SimpleFileSystem to register a Blob when performing the CreateSnapshotFile function.

webkit/tools/test_shell/simple_file_system.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "webkit/tools/test_shell/simple_file_system.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "googleurl/src/gurl.h"
+#include "net/base/mime_util.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFileInfo.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFileSystemCallbacks.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFileSystemEntry.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURL.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebVector.h"
+#include "webkit/blob/blob_storage_controller.h"
 #include "webkit/fileapi/mock_file_system_options.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/tools/test_shell/simple_file_writer.h"
 
 using base::WeakPtr;
 
 using WebKit::WebFileInfo;
 using WebKit::WebFileSystem;
 using WebKit::WebFileSystemCallbacks;
 using WebKit::WebFileSystemEntry;
 using WebKit::WebFileWriter;
 using WebKit::WebFileWriterClient;
 using WebKit::WebFrame;
 using WebKit::WebSecurityOrigin;
 using WebKit::WebString;
 using WebKit::WebURL;
 using WebKit::WebVector;
 
+using webkit_blob::BlobData;
+using webkit_blob::BlobStorageController;
 using fileapi::FileSystemContext;
 using fileapi::FileSystemOperationInterface;
 
+namespace {
+MessageLoop* g_io_thread;
+webkit_blob::BlobStorageController* g_blob_storage_controller;
+
+void RegisterBlob(const GURL& blob_url, const FilePath& file_path) {
+  DCHECK(g_blob_storage_controller);
+
+  FilePath::StringType extension = file_path.Extension();
+  if (!extension.empty())
+    extension = extension.substr(1);  // Strip leading ".".
+
+  // This may fail, but then we'll be just setting the empty mime type.
+  std::string mime_type;
+  net::GetWellKnownMimeTypeFromExtension(extension, &mime_type);
+
+  BlobData::Item item;
+  item.SetToFile(file_path, 0, -1, base::Time());
+  g_blob_storage_controller->StartBuildingBlob(blob_url);
+  g_blob_storage_controller->AppendBlobDataItem(blob_url, item);
+  g_blob_storage_controller->FinishBuildingBlob(blob_url, mime_type);
+}
+
+}  // namespace
+
 SimpleFileSystem::SimpleFileSystem() {
   if (file_system_dir_.CreateUniqueTempDir()) {
     file_system_context_ = new FileSystemContext(
         base::MessageLoopProxy::current(),
         base::MessageLoopProxy::current(),
         NULL /* special storage policy */,
         NULL /* quota manager */,
         file_system_dir_.path(),
         fileapi::CreateAllowFileAccessOptions());
   } else {
@@ skipping 92 matching lines @@
 
 WebFileWriter* SimpleFileSystem::createFileWriter(
     const WebURL& path, WebFileWriterClient* client) {
   return new SimpleFileWriter(path, client, file_system_context_.get());
 }
 
 void SimpleFileSystem::createSnapshotFileAndReadMetadata(
     const WebURL& blobURL,
     const WebURL& path,
     WebFileSystemCallbacks* callbacks) {
-  // TODO(michaeln): Register the blobURL with the blob storage contoller.
   GetNewOperation(path)->CreateSnapshotFile(
-      path, SnapshotFileHandler(callbacks));
+      path, SnapshotFileHandler(blobURL, callbacks));
+}
+
+// static
+void SimpleFileSystem::InitializeOnIOThread(
+    webkit_blob::BlobStorageController* blob_storage_controller) {
+  g_io_thread = MessageLoop::current();
+  g_blob_storage_controller = blob_storage_controller;
+}
+
+// static
+void SimpleFileSystem::CleanupOnIOThread() {
+  g_io_thread = NULL;
+  g_blob_storage_controller = NULL;
 }
 
 FileSystemOperationInterface* SimpleFileSystem::GetNewOperation(
     const WebURL& url) {
   return file_system_context_->CreateFileSystemOperation(
       GURL(url),
       base::MessageLoopProxy::current());
 }
 
 FileSystemOperationInterface::StatusCallback
@@ skipping 14 matching lines @@
                     AsWeakPtr(), base::Unretained(callbacks));
 }
 
 FileSystemContext::OpenFileSystemCallback
 SimpleFileSystem::OpenFileSystemHandler(WebFileSystemCallbacks* callbacks) {
   return base::Bind(&SimpleFileSystem::DidOpenFileSystem,
                     AsWeakPtr(), base::Unretained(callbacks));
 }
 
 FileSystemOperationInterface::SnapshotFileCallback
-SimpleFileSystem::SnapshotFileHandler(WebFileSystemCallbacks* callbacks) {
+SimpleFileSystem::SnapshotFileHandler(const GURL& blob_url,
+                                      WebFileSystemCallbacks* callbacks) {
   return base::Bind(&SimpleFileSystem::DidCreateSnapshotFile,
-                    AsWeakPtr(), base::Unretained(callbacks));
+                    AsWeakPtr(), blob_url, base::Unretained(callbacks));
 }
 
 void SimpleFileSystem::DidFinish(WebFileSystemCallbacks* callbacks,
                                  base::PlatformFileError result) {
   if (result == base::PLATFORM_FILE_OK)
     callbacks->didSucceed();
   else
     callbacks->didFail(webkit_glue::PlatformFileErrorToWebFileError(result));
 }
 
@@ skipping 44 matching lines @@
     if (!root.is_valid())
       callbacks->didFail(WebKit::WebFileErrorSecurity);
     else
       callbacks->didOpenFileSystem(WebString::fromUTF8(name), root);
   } else {
     callbacks->didFail(webkit_glue::PlatformFileErrorToWebFileError(result));
   }
 }
 
 void SimpleFileSystem::DidCreateSnapshotFile(
+    const GURL& blob_url,
     WebFileSystemCallbacks* callbacks,
     base::PlatformFileError result,
     const base::PlatformFileInfo& info,
     const FilePath& platform_path,
     const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref) {
+  DCHECK(g_io_thread);
+  if (result == base::PLATFORM_FILE_OK) {
+    g_io_thread->PostTask(
+        FROM_HERE,
+        base::Bind(&RegisterBlob, blob_url, platform_path));
+  }
   DidGetMetadata(callbacks, result, info, platform_path);
 }