Refactor "IsUnderDriveMountPoint" in v2 app code for generalization to non-Drive volumes.

chrome/browser/extensions/api/file_handlers/app_file_handler_util.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/api/file_handlers/app_file_handler_util.h"
 
 #include "apps/browser/file_handler_util.h"
 #include "base/file_util.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/render_process_host.h"
 #include "extensions/browser/extension_prefs.h"
 #include "net/base/mime_util.h"
 #include "webkit/browser/fileapi/isolated_context.h"
 #include "webkit/common/fileapi/file_system_mount_option.h"
 #include "webkit/common/fileapi/file_system_types.h"
 
 #if defined(OS_CHROMEOS)
-#include "chrome/browser/chromeos/drive/file_system_util.h"
+#include "chrome/browser/chromeos/file_manager/filesystem_api_util.h"
 #endif
 
 using apps::file_handler_util::GrantedFileEntry;
 
 namespace extensions {
 
 namespace app_file_handler_util {
 
 const char kInvalidParameters[] = "Invalid parameters";
 const char kSecurityError[] = "Security error";
@@ skipping 77 matching lines @@
   // calls the success or failure callback.
   void TaskDone();
 
   // Reports an error in completing a work item. This may be called more than
   // once, but only the last message will be retained.
   void Error(const base::FilePath& error_path);
 
   void CheckLocalWritableFiles();
 
 #if defined(OS_CHROMEOS)
-  void CheckRemoteWritableFile(const base::FilePath& remote_path,
-                               drive::FileError error,
-                               const base::FilePath& local_path);
-  void RemoteCheckDone(const base::FilePath& remote_path,
-                       drive::FileError error);
+  void SpecialPathCheckDone(const base::FilePath& path, bool success);
 #endif
 
   const std::vector<base::FilePath> paths_;
   Profile* profile_;
   const bool is_directory_;
   int outstanding_tasks_;
   base::FilePath error_path_;
   base::Closure on_success_;
   base::Callback<void(const base::FilePath&)> on_failure_;
 };
 
 WritableFileChecker::WritableFileChecker(
     const std::vector<base::FilePath>& paths,
     Profile* profile,
     bool is_directory,
     const base::Closure& on_success,
     const base::Callback<void(const base::FilePath&)>& on_failure)
     : paths_(paths),
       profile_(profile),
       is_directory_(is_directory),
       outstanding_tasks_(1),
       on_success_(on_success),
       on_failure_(on_failure) {}
 
 void WritableFileChecker::Check() {
 #if defined(OS_CHROMEOS)
-  if (drive::util::IsUnderDriveMountPoint(paths_[0])) {
+  if (file_manager::util::IsUnderSpecialPath(profile_, paths_[0])) {
     outstanding_tasks_ = paths_.size();
     for (std::vector<base::FilePath>::const_iterator it = paths_.begin();
          it != paths_.end();
          ++it) {
-      DCHECK(drive::util::IsUnderDriveMountPoint(*it));
+      DCHECK(file_manager::util::IsUnderSpecialPath(profile_, paths_[0]));
       if (is_directory_) {
-        drive::util::CheckDirectoryExists(
+        file_manager::util::IsSpecialPathDirectory(
             profile_,
             *it,
-            base::Bind(&WritableFileChecker::RemoteCheckDone, this, *it));
+            base::Bind(&WritableFileChecker::SpecialPathCheckDone, this, *it));
       } else {
-        drive::util::PrepareWritableFileAndRun(
+        file_manager::util::PrepareSpecialPathWritableFile(
             profile_,
             *it,
-            base::Bind(&WritableFileChecker::CheckRemoteWritableFile, this,
-                       *it));
+            base::Bind(&WritableFileChecker::SpecialPathCheckDone, this, *it));
       }
     }
     return;
   }
 #endif
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&WritableFileChecker::CheckLocalWritableFiles, this));
 }
@@ skipping 32 matching lines @@
       return;
     }
   }
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&WritableFileChecker::TaskDone, this));
 }
 
 #if defined(OS_CHROMEOS)
-void WritableFileChecker::CheckRemoteWritableFile(
-    const base::FilePath& remote_path,
-    drive::FileError error,
-    const base::FilePath& /* local_path */) {
-  RemoteCheckDone(remote_path, error);
-}
-
-void WritableFileChecker::RemoteCheckDone(
-    const base::FilePath& remote_path,
-    drive::FileError error) {
-  if (error == drive::FILE_ERROR_OK) {
-    content::BrowserThread::PostTask(
-        content::BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(&WritableFileChecker::TaskDone, this));
-  } else {
-    content::BrowserThread::PostTask(
-        content::BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(&WritableFileChecker::Error, this, remote_path));
-  }
+void WritableFileChecker::SpecialPathCheckDone(const base::FilePath& path,
+                                               bool success) {
+  if (success)
+    TaskDone();
+  else
+    Error(path);
 }
 #endif
 
 }  // namespace
 
 const FileHandlerInfo* FileHandlerForId(const Extension& app,
                                         const std::string& handler_id) {
   const FileHandlersInfo* file_handlers = FileHandlers::GetFileHandlers(&app);
   if (!file_handlers)
     return NULL;
@@ skipping 151 matching lines @@
     *error = kInvalidParameters;
     return false;
   }
 
   return true;
 }
 
 }  // namespace app_file_handler_util
 
 }  // namespace extensions