Wire-up DeleteFileSystem to DumpRenderTree

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"
@@ skipping 73 matching lines @@
   } else {
     LOG(WARNING) << "Failed to create a temp dir for the filesystem."
                     "FileSystem feature will be disabled.";
   }
 }
 
 SimpleFileSystem::~SimpleFileSystem() {
 }
 
 void SimpleFileSystem::OpenFileSystem(
-    WebFrame* frame, WebFileSystem::Type web_filesystem_type,
+    WebFrame* frame, WebFileSystem::Type type,
     long long, bool create,
     WebFileSystemCallbacks* callbacks) {
   if (!frame || !file_system_context_.get()) {
     // The FileSystem temp directory was not initialized successfully.
     callbacks->didFail(WebKit::WebFileErrorSecurity);
     return;
   }
 
-  fileapi::FileSystemType type;
-  if (web_filesystem_type == WebFileSystem::TypeTemporary)
-    type = fileapi::kFileSystemTypeTemporary;
-  else if (web_filesystem_type == WebFileSystem::TypePersistent)
-    type = fileapi::kFileSystemTypePersistent;
-  else if (web_filesystem_type == WebFileSystem::TypeExternal)
-    type = fileapi::kFileSystemTypeExternal;
-  else {
-    // Unknown type filesystem is requested.
+  GURL origin_url(frame->document().securityOrigin().toString());
+  file_system_context_->OpenFileSystem(
+      origin_url, static_cast<fileapi::FileSystemType>(type), create,
+      OpenFileSystemHandler(callbacks));
+}
+
+void SimpleFileSystem::DeleteFileSystem(
+    WebFrame* frame, WebFileSystem::Type type,
+    WebFileSystemCallbacks* callbacks) {
+  if (!frame || !file_system_context_.get()) {
     callbacks->didFail(WebKit::WebFileErrorSecurity);
     return;
   }
 
   GURL origin_url(frame->document().securityOrigin().toString());
-  file_system_context_->OpenFileSystem(
-      origin_url, type, create, OpenFileSystemHandler(callbacks));
+  file_system_context_->DeleteFileSystem(
+      origin_url, static_cast<fileapi::FileSystemType>(type),
+      DeleteFileSystemHandler(callbacks));
 }
 
 void SimpleFileSystem::move(
     const WebURL& src_path,
     const WebURL& dest_path, WebFileSystemCallbacks* callbacks) {
   FileSystemURL src_url(src_path);
   FileSystemURL dest_url(dest_path);
   if (!HasFilePermission(src_url, FILE_PERMISSION_WRITE) ||
       !HasFilePermission(dest_url, FILE_PERMISSION_CREATE)) {
     callbacks->didFail(WebKit::WebFileErrorSecurity);
@@ skipping 160 matching lines @@
   return base::Bind(&SimpleFileSystem::DidGetMetadata,
                     AsWeakPtr(), base::Unretained(callbacks));
 }
 
 FileSystemContext::OpenFileSystemCallback
 SimpleFileSystem::OpenFileSystemHandler(WebFileSystemCallbacks* callbacks) {
   return base::Bind(&SimpleFileSystem::DidOpenFileSystem,
                     AsWeakPtr(), base::Unretained(callbacks));
 }
 
+FileSystemContext::DeleteFileSystemCallback
+SimpleFileSystem::DeleteFileSystemHandler(WebFileSystemCallbacks* callbacks) {
+  return base::Bind(&SimpleFileSystem::DidDeleteFileSystem,
+                    AsWeakPtr(), callbacks);
+}
+
 FileSystemOperationInterface::SnapshotFileCallback
 SimpleFileSystem::SnapshotFileHandler(const GURL& blob_url,
                                       WebFileSystemCallbacks* callbacks) {
   return base::Bind(&SimpleFileSystem::DidCreateSnapshotFile,
                     AsWeakPtr(), blob_url, base::Unretained(callbacks));
 }
 
 void SimpleFileSystem::DidFinish(WebFileSystemCallbacks* callbacks,
                                  base::PlatformFileError result) {
   if (result == base::PLATFORM_FILE_OK)
@@ skipping 48 matching lines @@
   if (result == base::PLATFORM_FILE_OK) {
     if (!root.is_valid())
       callbacks->didFail(WebKit::WebFileErrorSecurity);
     else
       callbacks->didOpenFileSystem(WebString::fromUTF8(name), root);
   } else {
     callbacks->didFail(fileapi::PlatformFileErrorToWebFileError(result));
   }
 }
 
+void SimpleFileSystem::DidDeleteFileSystem(
+    WebFileSystemCallbacks* callbacks,
+    base::PlatformFileError result) {
+  if (result == base::PLATFORM_FILE_OK)
+    callbacks->didSucceed();
+  else
+    callbacks->didFail(fileapi::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);
 }