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 161 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) {
+  base::PostTaskAndReplyWithResult(
+      context->file_task_runner(),
+      FROM_HERE,
+      // It is safe to pass Unretained(this) since context owns it.
+      base::Bind(&SandboxMountPointProvider::DeleteOriginDataOnFileThread,
+                 base::Unretained(this),
+                 make_scoped_refptr(context),
+                 base::Unretained(context->quota_manager_proxy()),
+                 origin_url,
+                 type),
+      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 11 matching lines @@
   MigrateIfNeeded(sandbox_file_util_.get(), old_base_path());
 
   base::PlatformFileError error = base::PLATFORM_FILE_OK;
   FilePath path = sandbox_file_util_->GetDirectoryForOriginAndType(
       origin_url, type, create, &error);
   if (error != base::PLATFORM_FILE_OK)
     return FilePath();
   return path;
 }
 
-bool SandboxMountPointProvider::DeleteOriginDataOnFileThread(
+base::PlatformFileError
+SandboxMountPointProvider::DeleteOriginDataOnFileThread(
     FileSystemContext* file_system_context,
     QuotaManagerProxy* proxy,
     const GURL& origin_url,
     fileapi::FileSystemType type) {
   MigrateIfNeeded(sandbox_file_util_.get(), old_base_path());
 
   int64 usage = GetOriginUsageOnFileThread(file_system_context,
                                            origin_url, type);
 
   bool result =
       sandbox_file_util_->DeleteDirectoryForOriginAndType(origin_url, type);
   if (result && proxy) {
     proxy->NotifyStorageModified(
         quota::QuotaClient::kFileSystem,
         origin_url,
         FileSystemTypeToQuotaStorageType(type),
         -usage);
   }
-  return result;
+
+  if (result)
+    return base::PLATFORM_FILE_OK;
+  return base::PLATFORM_FILE_ERROR_FAILED;
 }
 
 void SandboxMountPointProvider::GetOriginsForTypeOnFileThread(
     fileapi::FileSystemType type, std::set<GURL>* origins) {
   DCHECK(type == kFileSystemTypeTemporary ||
          type == kFileSystemTypePersistent);
   DCHECK(origins);
   scoped_ptr<OriginEnumerator> enumerator(CreateOriginEnumerator());
   GURL origin;
   while (!(origin = enumerator->Next()).is_empty()) {
@@ skipping 210 matching lines @@
       break;
     case base::PLATFORM_FILE_ERROR_FAILED:
     default:
       REPORT(kUnknownError);
       break;
   }
 #undef REPORT
 }
 
 }  // namespace fileapi