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 292 matching lines @@
     mount_info->SetString("mountCondition",
         DiskMountManager::MountConditionToString(
             mount_point_info.mount_condition));
 
     return mount_info;
 }
 #endif
 
 }  // namespace
 
-class RequestLocalFileSystemFunction::LocalFileSystemCallbackDispatcher
-    : public fileapi::FileSystemCallbackDispatcher {
+class RequestLocalFileSystemFunction::LocalFileSystemCallbackDispatcher {
  public:
-  static scoped_ptr<FileSystemCallbackDispatcher> Create(
+  static fileapi::FileSystemContext::OpenFileSystemCallback CreateCallback(
       RequestLocalFileSystemFunction* function,
       Profile* profile,
       int child_id,
       scoped_refptr<const Extension> extension) {
-    return scoped_ptr<fileapi::FileSystemCallbackDispatcher>(
-        new LocalFileSystemCallbackDispatcher(
-            function, profile, child_id, extension));
+    return base::Bind(
+        &LocalFileSystemCallbackDispatcher::DidOpenFileSystem,
+        base::Owned(new LocalFileSystemCallbackDispatcher(
+            function, profile, child_id, extension)));
   }
 
-  // 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 {
+  void DidOpenFileSystem(base::PlatformFileError result,
+                         const std::string& name,
+                         const GURL& root_path) OVERRIDE {
+    if (result != base::PLATFORM_FILE_OK) {
+      DidFail(result);
+      return;
+    }
     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));
   }
 
-  virtual void DidFail(base::PlatformFileError error_code) OVERRIDE {
+  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::Create(
+      LocalFileSystemCallbackDispatcher::CreateCallback(
           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
-    : public fileapi::FileSystemCallbackDispatcher {
+class
+  ExecuteTasksFileBrowserFunction::ExecuteTasksFileSystemCallbackDispatcher {
  public:
-  static scoped_ptr<fileapi::FileSystemCallbackDispatcher> Create(
+  static fileapi::FileSystemContext::OpenFileSystemCallback CreateCallback(

[kinuko, 2012/02/10 05:34:09]

Nice practical solution.

[kinaba, 2012/02/10 08:22:58]

:)

       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 scoped_ptr<fileapi::FileSystemCallbackDispatcher>(
-        new ExecuteTasksFileSystemCallbackDispatcher(
+    return base::Bind(
+        &ExecuteTasksFileSystemCallbackDispatcher::DidOpenFileSystem,
+        base::Owned(new ExecuteTasksFileSystemCallbackDispatcher(
             function, profile, child_id, source_url, extension,
-            task_id, file_urls));
+            task_id, file_urls)));
   }
 
-  // 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 {
+  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;
+    }
     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));
   }
 
-  virtual void DidFail(base::PlatformFileError error_code) OVERRIDE {
+  void DidFail(base::PlatformFileError error_code) {
     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::Create(
+      ExecuteTasksFileSystemCallbackDispatcher::CreateCallback(
           this,
           profile(),
           render_view_host()->process()->GetID(),
           source_url,
           GetExtension(),
           task_id,
           file_urls));
 }
 
 void ExecuteTasksFileBrowserFunction::ExecuteFailedOnUIThread() {
@@ skipping 774 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;
 }