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

chrome/browser/extensions/extension_file_browser_private_api.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 "chrome/browser/extensions/extension_file_browser_private_api.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
@@ skipping 296 matching lines @@
     mount_info->SetString("mountCondition",
         DiskMountManager::MountConditionToString(
             mount_point_info.mount_condition));
 
     return mount_info;
 }
 #endif
 
 }  // namespace
 
-class RequestLocalFileSystemFunction::LocalFileSystemCallbackDispatcher {
+class RequestLocalFileSystemFunction::LocalFileSystemCallbackDispatcher
+    : public fileapi::FileSystemCallbackDispatcher {
  public:
-  static fileapi::FileSystemContext::OpenFileSystemCallback CreateCallback(
+  static scoped_ptr<FileSystemCallbackDispatcher> Create(
       RequestLocalFileSystemFunction* function,
       Profile* profile,
       int child_id,
       scoped_refptr<const Extension> extension) {
-    return base::Bind(
-        &LocalFileSystemCallbackDispatcher::DidOpenFileSystem,
-        base::Owned(new LocalFileSystemCallbackDispatcher(
-            function, profile, child_id, extension)));
+    return scoped_ptr<fileapi::FileSystemCallbackDispatcher>(
+        new LocalFileSystemCallbackDispatcher(
+            function, profile, child_id, extension));
   }
 
-  void DidOpenFileSystem(base::PlatformFileError result,
-                         const std::string& name,
-                         const GURL& root_path) OVERRIDE {
-    if (result != base::PLATFORM_FILE_OK) {
-      DidFail(result);
-      return;
-    }
+  // fileapi::FileSystemCallbackDispatcher overrides.
+  virtual void DidSucceed() OVERRIDE {
+    NOTREACHED();
+  }
+
+  virtual void DidReadMetadata(const base::PlatformFileInfo& info,
+                               const FilePath& unused) OVERRIDE {
+    NOTREACHED();
+  }
+
+  virtual void DidReadDirectory(
+      const std::vector<base::FileUtilProxy::Entry>& entries,
+      bool has_more) OVERRIDE {
+    NOTREACHED();
+  }
+
+  virtual void DidWrite(int64 bytes, bool complete) OVERRIDE {
+    NOTREACHED();
+  }
+
+  virtual void DidOpenFileSystem(const std::string& name,
+                                 const GURL& root_path) OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
     // Set up file permission access.
     if (!SetupFileSystemAccessPermissions()) {
       DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
       return;
     }
 
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(
             &RequestLocalFileSystemFunction::RespondSuccessOnUIThread,
             function_,
             name,
             root_path));
   }
 
-  void DidFail(base::PlatformFileError error_code) OVERRIDE {
+  virtual void DidFail(base::PlatformFileError error_code) OVERRIDE {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(
             &RequestLocalFileSystemFunction::RespondFailedOnUIThread,
             function_,
             error_code));
   }
 
  private:
   LocalFileSystemCallbackDispatcher(
@@ skipping 48 matching lines @@
   // Extension source URL.
   scoped_refptr<const Extension> extension_;
   DISALLOW_COPY_AND_ASSIGN(LocalFileSystemCallbackDispatcher);
 };
 
 void RequestLocalFileSystemFunction::RequestOnFileThread(
     const GURL& source_url, int child_id) {
   GURL origin_url = source_url.GetOrigin();
   profile()->GetFileSystemContext()->OpenFileSystem(
       origin_url, fileapi::kFileSystemTypeExternal, false, // create
-      LocalFileSystemCallbackDispatcher::CreateCallback(
+      LocalFileSystemCallbackDispatcher::Create(
           this,
           profile(),
           child_id,
           GetExtension()));
 }
 
 bool RequestLocalFileSystemFunction::RunImpl() {
   if (!dispatcher() || !render_view_host() || !render_view_host()->process())
     return false;
 
@@ skipping 173 matching lines @@
     task->SetString("iconUrl", icon.spec());
     result_list->Append(task);
   }
 
   // TODO(zelidrag, serya): Add intent content tasks to result_list once we
   // implement that API.
   SendResponse(true);
   return true;
 }
 
-class
-  ExecuteTasksFileBrowserFunction::ExecuteTasksFileSystemCallbackDispatcher {
+class ExecuteTasksFileBrowserFunction::ExecuteTasksFileSystemCallbackDispatcher
+    : public fileapi::FileSystemCallbackDispatcher {
  public:
-  static fileapi::FileSystemContext::OpenFileSystemCallback CreateCallback(
+  static scoped_ptr<fileapi::FileSystemCallbackDispatcher> Create(
       ExecuteTasksFileBrowserFunction* function,
       Profile* profile,
       int child_id,
       const GURL& source_url,
       scoped_refptr<const Extension> extension,
       const std::string task_id,
       const std::vector<GURL>& file_urls) {
-    return base::Bind(
-        &ExecuteTasksFileSystemCallbackDispatcher::DidOpenFileSystem,
-        base::Owned(new ExecuteTasksFileSystemCallbackDispatcher(
+    return scoped_ptr<fileapi::FileSystemCallbackDispatcher>(
+        new ExecuteTasksFileSystemCallbackDispatcher(
             function, profile, child_id, source_url, extension,
-            task_id, file_urls)));
+            task_id, file_urls));
   }
 
-  void DidOpenFileSystem(base::PlatformFileError result,
-                         const std::string& file_system_name,
-                         const GURL& file_system_root) OVERRIDE {
-    if (result != base::PLATFORM_FILE_OK) {
-      DidFail(result);
-      return;
-    }
+  // fileapi::FileSystemCallbackDispatcher overrides.
+  virtual void DidSucceed() OVERRIDE {
+    NOTREACHED();
+  }
+
+  virtual void DidReadMetadata(const base::PlatformFileInfo& info,
+                               const FilePath& unused) OVERRIDE {
+    NOTREACHED();
+  }
+
+  virtual void DidReadDirectory(
+      const std::vector<base::FileUtilProxy::Entry>& entries,
+      bool has_more) OVERRIDE {
+    NOTREACHED();
+  }
+
+  virtual void DidWrite(int64 bytes, bool complete) OVERRIDE {
+    NOTREACHED();
+  }
+
+  virtual void DidOpenFileSystem(const std::string& file_system_name,
+                                 const GURL& file_system_root) OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
     ExecuteTasksFileBrowserFunction::FileDefinitionList file_list;
     for (std::vector<GURL>::iterator iter = origin_file_urls_.begin();
          iter != origin_file_urls_.end();
          ++iter) {
       // Set up file permission access.
       ExecuteTasksFileBrowserFunction::FileDefinition file;
       if (!SetupFileAccessPermissions(*iter, &file.target_file_url,
                                       &file.virtual_path, &file.is_directory)) {
         continue;
@@ skipping 13 matching lines @@
         BrowserThread::UI, FROM_HERE,
         base::Bind(
             &ExecuteTasksFileBrowserFunction::ExecuteFileActionsOnUIThread,
             function_,
             task_id_,
             file_system_name,
             file_system_root,
             file_list));
   }
 
-  void DidFail(base::PlatformFileError error_code) {
+  virtual void DidFail(base::PlatformFileError error_code) OVERRIDE {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(
             &ExecuteTasksFileBrowserFunction::ExecuteFailedOnUIThread,
             function_));
   }
 
  private:
   ExecuteTasksFileSystemCallbackDispatcher(
       ExecuteTasksFileBrowserFunction* function,
@@ skipping 178 matching lines @@
   return true;
 }
 
 void ExecuteTasksFileBrowserFunction::RequestFileEntryOnFileThread(
     const GURL& source_url, const std::string& task_id,
     const std::vector<GURL>& file_urls) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   GURL origin_url = source_url.GetOrigin();
   profile()->GetFileSystemContext()->OpenFileSystem(
       origin_url, fileapi::kFileSystemTypeExternal, false, // create
-      ExecuteTasksFileSystemCallbackDispatcher::CreateCallback(
+      ExecuteTasksFileSystemCallbackDispatcher::Create(
           this,
           profile(),
           render_view_host()->process()->GetID(),
           source_url,
           GetExtension(),
           task_id,
           file_urls));
 }
 
 void ExecuteTasksFileBrowserFunction::ExecuteFailedOnUIThread() {
@@ skipping 812 matching lines @@
   SET_STRING(IDS_FILE_BROWSER, ENQUEUE);
 #undef SET_STRING
 
   ChromeURLDataManager::DataSource::SetFontAndTextDirection(dict);
 
   dict->SetString("PLAY_MEDIA",
       l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_PLAY));
 
   return true;
 }