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 100 matching lines @@
     // Unknown type filesystem is requested.
     callbacks->didFail(WebKit::WebFileErrorSecurity);
     return;
   }
 
   GURL origin_url(frame->document().securityOrigin().toString());
   file_system_context_->OpenFileSystem(
       origin_url, type, create, OpenFileSystemHandler(callbacks));
 }
 
+void SimpleFileSystem::DeleteFileSystem(
+    WebFrame* frame, WebFileSystem::Type web_filesystem_type,
+    WebFileSystemCallbacks* callbacks) {
+  if (!frame || !file_system_context_.get()) {
+    callbacks->didFail(WebKit::WebFileErrorSecurity);
+    return;

[kinuko, 2012/08/15 06:15:58]

We silently return success in RenderViewImpl in this case.  Maybe we should do
the same?

[tzik, 2012/08/15 06:53:36]

We return success in RVI if the origin is unique (e.g. data: scheme URI).
I think the condition in this CL is different to RVI case.

+  }
+
+  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;

[kinuko, 2012/08/15 06:15:58]

These explicit assignments are not really necessary.  Maybe we should just pass
the type to FileSystemContext and let it handle unknown type cases? (Probably we
should do the same in OpenFileSystem)

[tzik, 2012/08/15 06:53:36]

Done.

+  else {
+    // Unknown type filesystem is requested.
+    callbacks->didFail(WebKit::WebFileErrorSecurity);
+    return;
+  }
+
+  GURL origin_url(frame->document().securityOrigin().toString());
+  file_system_context_->DeleteFileSystem(
+      origin_url, 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);
     return;
   }
@@ skipping 158 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);
 }