Revert 121620 - Refactor FileSystemOperation to take callback for each method.

webkit/fileapi/file_system_context.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/file_system_context.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/message_loop_proxy.h"
 #include "googleurl/src/gurl.h"
+#include "webkit/fileapi/file_system_callback_dispatcher.h"
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_operation_interface.h"
 #include "webkit/fileapi/file_system_options.h"
 #include "webkit/fileapi/file_system_quota_client.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/sandbox_mount_point_provider.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/quota/special_storage_policy.h"
 
 #if defined(OS_CHROMEOS)
 #include "webkit/chromeos/fileapi/cros_mount_point_provider.h"
 #endif
 
 using quota::QuotaClient;
 
 namespace fileapi {
 
 namespace {
 
 QuotaClient* CreateQuotaClient(
     scoped_refptr<base::MessageLoopProxy> file_message_loop,
     FileSystemContext* context,
     bool is_incognito) {
   return new FileSystemQuotaClient(file_message_loop, context, is_incognito);
 }
 
-void DidOpenFileSystem(FileSystemContext::OpenFileSystemCallback callback,
+void DidOpenFileSystem(scoped_ptr<FileSystemCallbackDispatcher> dispatcher,
                        const GURL& filesystem_root,
                        const std::string& filesystem_name,
                        base::PlatformFileError error) {
-  callback.Run(error, filesystem_name, filesystem_root);
+  if (error == base::PLATFORM_FILE_OK) {
+    dispatcher->DidOpenFileSystem(filesystem_name, filesystem_root);
+  } else {
+    dispatcher->DidFail(error);
+  }
 }
 
 }  // anonymous namespace
 
 FileSystemContext::FileSystemContext(
     scoped_refptr<base::MessageLoopProxy> file_message_loop,
     scoped_refptr<base::MessageLoopProxy> io_message_loop,
     scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy,
     quota::QuotaManagerProxy* quota_manager_proxy,
     const FilePath& profile_path,
@@ skipping 93 matching lines @@
     io_message_loop_->DeleteSoon(FROM_HERE, this);
     return;
   }
   delete this;
 }
 
 void FileSystemContext::OpenFileSystem(
     const GURL& origin_url,
     FileSystemType type,
     bool create,
-    OpenFileSystemCallback callback) {
-  DCHECK(!callback.is_null());
+    scoped_ptr<FileSystemCallbackDispatcher> dispatcher) {
+  DCHECK(dispatcher.get());
 
   FileSystemMountPointProvider* mount_point_provider =
       GetMountPointProvider(type);
   if (!mount_point_provider) {
-    callback.Run(base::PLATFORM_FILE_ERROR_SECURITY, std::string(), GURL());
+    dispatcher->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
     return;
   }
 
   GURL root_url = GetFileSystemRootURI(origin_url, type);
   std::string name = GetFileSystemName(origin_url, type);
 
   mount_point_provider->ValidateFileSystemRoot(
       origin_url, type, create,
-      base::Bind(&DidOpenFileSystem, callback, root_url, name));
+      base::Bind(&DidOpenFileSystem,
+                 base::Passed(&dispatcher), root_url, name));
 }
 
 FileSystemOperationInterface* FileSystemContext::CreateFileSystemOperation(
     const GURL& url,
+    scoped_ptr<FileSystemCallbackDispatcher> dispatcher,
     base::MessageLoopProxy* file_proxy) {
   GURL origin_url;
   FileSystemType file_system_type = kFileSystemTypeUnknown;
   FilePath file_path;
   if (!CrackFileSystemURL(url, &origin_url, &file_system_type, &file_path))
     return NULL;
   FileSystemMountPointProvider* mount_point_provider =
       GetMountPointProvider(file_system_type);
   if (!mount_point_provider)
     return NULL;
   return mount_point_provider->CreateFileSystemOperation(
-      origin_url, file_system_type, file_path, file_proxy, this);
+      origin_url, file_system_type, file_path,
+      dispatcher.Pass(), file_proxy, this);
 }
 
 }  // namespace fileapi