Wire up the deleteFileSystem operation.

webkit/fileapi/sandbox_mount_point_provider.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/fileapi/sandbox_mount_point_provider.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
+#include "base/task_runner_util.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
 #include "webkit/fileapi/file_system_file_stream_reader.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_options.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/local_file_system_operation.h"
 #include "webkit/fileapi/native_file_util.h"
@@ skipping 235 matching lines @@
 // done before anyone looks up a filesystem.  Most entry points start by trying
 // to look up the filesystem's root, so we can take care of most of them by
 // putting a check there.
 void MigrateIfNeeded(
     ObfuscatedFileUtil* file_util,
     const FilePath& old_base_path) {
   if (file_util::DirectoryExists(old_base_path))
     MigrateAllOldFileSystems(file_util, old_base_path);
 }
 
-void PassPointerErrorByValue(
-    const base::Callback<void(PlatformFileError)>& callback,
-    PlatformFileError* error_ptr) {
-  DCHECK(error_ptr);
-  callback.Run(*error_ptr);
-}
-
 void DidValidateFileSystemRoot(
     base::WeakPtr<SandboxMountPointProvider> mount_point_provider,
-    const base::Callback<void(PlatformFileError)>& callback,
+    const FileSystemMountPointProvider::ValidateFileSystemCallback& callback,
     base::PlatformFileError* error) {
   if (mount_point_provider.get())
     mount_point_provider.get()->CollectOpenFileSystemMetrics(*error);
   callback.Run(*error);
 }
 
 void ValidateRootOnFileThread(
     ObfuscatedFileUtil* file_util,
     const GURL& origin_url,
     FileSystemType type,
@@ skipping 11 matching lines @@
                               kCreateDirectoryError,
                               kFileSystemErrorMax);
   } else {
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel, kOK, kFileSystemErrorMax);
   }
   // The reference of file_util will be derefed on the FILE thread
   // when the storage of this callback gets deleted regardless of whether
   // this method is called or not.
 }
 
+base::PlatformFileError DeleteFileSystemOnFileThread(
+    const GURL& origin_url,
+    FileSystemType type,
+    FileSystemContext* context) {
+  return context->DeleteDataForOriginAndTypeOnFileThread(origin_url, type);
+}
+
 }  // anonymous namespace
 
 const FilePath::CharType SandboxMountPointProvider::kOldFileSystemDirectory[] =
     FILE_PATH_LITERAL("FileSystem");
 
 const FilePath::CharType SandboxMountPointProvider::kNewFileSystemDirectory[] =
     FILE_PATH_LITERAL("File System");
 
 const FilePath::CharType
     SandboxMountPointProvider::kRenamedOldFileSystemDirectory[] =
@@ skipping 130 matching lines @@
     const FileSystemURL& url,
     int64 offset,
     FileSystemContext* context) const {
   return new SandboxFileStreamWriter(context, url, offset);
 }
 
 FileSystemQuotaUtil* SandboxMountPointProvider::GetQuotaUtil() {
   return this;
 }
 
+void SandboxMountPointProvider::DeleteFileSystem(
+    const GURL& origin_url,
+    FileSystemType type,
+    FileSystemContext* context,
+    const DeleteFileSystemCallback& callback) const {
+  base::PostTaskAndReplyWithResult(
+      context->file_task_runner(),
+      FROM_HERE,
+      base::Bind(&DeleteFileSystemOnFileThread,
+                 origin_url,
+                 type,
+                 make_scoped_refptr(context)),

[kinuko, 2012/08/01 05:52:04]

base::Bind(&FileSystemContext::DeleteDataForOriginAndTypeOnFileThread,
                 context, origin_url, type)

does the same?

Or.. looks like we can directly call this->DeleteOriginDataOnFileThread?

base::Bind(&SandboxMountPointProvider::DeleteOriginDataOnFileThread,
           weak_factory_.GetWeakPtr(),
           context, context->quota_manager_proxy(),
           origin_url, type);

[nhiroki (google), 2012/08/01 20:37:45]

The second case looks like difficult because WeakCalls are only supported for
functions with a void return type (see base/bind_internal.h) and
PostTaskAndReplyWithResult needs callback to return value.

I modified it according to the first case.

[kinuko, 2012/08/01 20:48:46]

I see, then is it possible to pass an unretained pointer of SMPP and pass
make_scoped_refptr(context) to the Bind?  (since SMPP is owned by context)

[nhiroki (google), 2012/08/01 22:35:43]

All right. I changed it to pass unretained pointer of SMPP and so on.

And I removed const specifier from DeleteFileSystem interface so as to pass
'this' (that is a pointer of SMPP).

Done.

+      callback);
+}
+
 FilePath SandboxMountPointProvider::old_base_path() const {
   return profile_path_.Append(kOldFileSystemDirectory);
 }
 
 FilePath SandboxMountPointProvider::new_base_path() const {
   return profile_path_.Append(kNewFileSystemDirectory);
 }
 
 FilePath SandboxMountPointProvider::renamed_old_base_path() const {
   return profile_path_.Append(kRenamedOldFileSystemDirectory);
@@ skipping 261 matching lines @@
       break;
     case base::PLATFORM_FILE_ERROR_FAILED:
     default:
       REPORT(kUnknownError);
       break;
   }
 #undef REPORT
 }
 
 }  // namespace fileapi