Cleanup FileSystemOperation for preparing for adding FSO-factory method

webkit/chromeos/fileapi/cros_mount_point_provider.cc

 // Copyright (c) 2011 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/chromeos/fileapi/cros_mount_point_provider.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_callback_factory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
@@ skipping 61 matching lines @@
   base::AutoLock locker(lock_);
   // Check if this root mount point is exposed by this provider.
   MountPointMap::iterator iter = mount_point_map_.find(components[0]);
   if (iter == mount_point_map_.end()) {
     return false;
   }
   *root_path = iter->second;
   return true;
 }
 
-void CrosMountPointProvider::ValidateFileSystemRootAndGetURL(
+void CrosMountPointProvider::ValidateFileSystemRoot(
     const GURL& origin_url,
     fileapi::FileSystemType type,
     bool create,
-    const GetRootPathCallback& callback) {
+    const ValidateFileSystemCallback& callback) {
+  // Nothing to validate for external filesystem.
   DCHECK(type == fileapi::kFileSystemTypeExternal);
-  std::string name(GetOriginIdentifierFromURL(origin_url));
-  name += ':';
-  name += fileapi::kExternalName;
-  FilePath root_path;
-  root_path = FilePath(fileapi::kExternalDir);
-  callback.Run(true, root_path, name);
+  callback.Run(base::PLATFORM_FILE_OK);
 }
 
-FilePath CrosMountPointProvider::ValidateFileSystemRootAndGetPathOnFileThread(
+FilePath CrosMountPointProvider::GetFileSystemRootPathOnFileThread(
     const GURL& origin_url,
     fileapi::FileSystemType type,
     const FilePath& virtual_path,
     bool create) {
   DCHECK(type == fileapi::kFileSystemTypeExternal);
   FilePath root_path;
   if (!GetRootForVirtualPath(virtual_path, &root_path))
     return FilePath();
 
   return root_path;
 }
 
-// TODO(zelidrag): Share this code with SandboxMountPointProvider impl.
-bool CrosMountPointProvider::IsRestrictedFileName(const FilePath& path) const {
-  return false;
-}
-
 bool CrosMountPointProvider::IsAccessAllowed(const GURL& origin_url,
                                              fileapi::FileSystemType type,
                                              const FilePath& virtual_path) {
   if (type != fileapi::kFileSystemTypeExternal)
     return false;
 
   // Permit access to mount points from internal WebUI.
   if (origin_url.SchemeIs(kChromeUIScheme))
     return true;
 
   std::string extension_id = origin_url.host();
   // Check first to make sure this extension has fileBrowserHander permissions.
   if (!special_storage_policy_->IsFileHandler(extension_id))
     return false;
 
   return file_access_permissions_->HasAccessPermission(extension_id,
                                                        virtual_path);
 }
 
+// TODO(zelidrag): Share this code with SandboxMountPointProvider impl.
+bool CrosMountPointProvider::IsRestrictedFileName(const FilePath& path) const {
+  return false;
+}
+
 void CrosMountPointProvider::AddMountPoint(FilePath mount_point) {
   base::AutoLock locker(lock_);
   mount_point_map_.erase(mount_point.BaseName().value());
   mount_point_map_.insert(std::pair<std::string, FilePath>(
       mount_point.BaseName().value(), mount_point.DirName()));
 }
 
 void CrosMountPointProvider::RemoveMountPoint(FilePath mount_point) {
   base::AutoLock locker(lock_);
   mount_point_map_.erase(mount_point.BaseName().value());
@@ skipping 51 matching lines @@
     } else if (mount_prefix == filesystem_path) {
       FilePath root = FilePath(FILE_PATH_LITERAL("/"));
       *virtual_path = root.Append(iter->first);
       return true;
     }
   }
   return false;
 }
 
 }  // namespace chromeos