Cleanup: Removing FileSystemPathManager

webkit/fileapi/sandbox_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/fileapi/sandbox_mount_point_provider.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_callback_factory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/metrics/histogram.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
 #include "webkit/fileapi/file_system_operation_context.h"
-#include "webkit/fileapi/file_system_path_manager.h"
+#include "webkit/fileapi/file_system_options.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/obfuscated_file_util.h"
 #include "webkit/fileapi/quota_file_util.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/quota/quota_manager.h"
 
 using quota::QuotaManagerProxy;
 
 namespace {
 
-static const FilePath::CharType kOldFileSystemUniqueNamePrefix[] =
+const char kChromeScheme[] = "chrome";
+const char kExtensionScheme[] = "chrome-extension";
+
+const FilePath::CharType kOldFileSystemUniqueNamePrefix[] =
     FILE_PATH_LITERAL("chrome-");
-static const int kOldFileSystemUniqueLength = 16;
-static const unsigned kOldFileSystemUniqueDirectoryNameLength =
+const size_t kOldFileSystemUniqueLength = 16;
+const size_t kOldFileSystemUniqueDirectoryNameLength =
     kOldFileSystemUniqueLength + arraysize(kOldFileSystemUniqueNamePrefix) - 1;
 
 const char kOpenFileSystem[] = "FileSystem.OpenFileSystem";
 enum FileSystemError {
   kOK = 0,
   kIncognito,
   kInvalidScheme,
   kCreateDirectoryError,
   kFileSystemErrorMax,
 };
 
 // Restricted names.
 // http://dev.w3.org/2009/dap/file-system/file-dir-sys.html#naming-restrictions
-static const char* const kRestrictedNames[] = {
-  ".", "..",
+const FilePath::CharType* const kRestrictedNames[] = {
+  FILE_PATH_LITERAL("."), FILE_PATH_LITERAL(".."),
 };
 
 // Restricted chars.
-static const FilePath::CharType kRestrictedChars[] = {
-  '/', '\\',
+const FilePath::CharType kRestrictedChars[] = {
+  FILE_PATH_LITERAL('/'), FILE_PATH_LITERAL('\\'),
 };
 
-inline std::string FilePathStringToASCII(
-    const FilePath::StringType& path_string) {
-#if defined(OS_WIN)
-  return WideToASCII(path_string);
-#elif defined(OS_POSIX)
-  return path_string;
-#endif
-}
-
 FilePath::StringType OldCreateUniqueDirectoryName(const GURL& origin_url) {
   // This can be anything but need to be unpredictable.
   static const FilePath::CharType letters[] = FILE_PATH_LITERAL(
     "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
   FilePath::StringType unique(kOldFileSystemUniqueNamePrefix);
-  for (int i = 0; i < kOldFileSystemUniqueLength; ++i)
+  for (size_t i = 0; i < kOldFileSystemUniqueLength; ++i)
     unique += letters[base::RandInt(0, arraysize(letters) - 2)];
   return unique;
 }
 
 base::PlatformFileError OldReadOriginDirectory(const FilePath& base_path,
                                                FilePath* unique) {
   file_util::FileEnumerator file_enum(
       base_path, false /* recursive */,
       file_util::FileEnumerator::DIRECTORIES,
       FilePath::StringType(kOldFileSystemUniqueNamePrefix) +
@@ skipping 44 matching lines @@
   explicit OldSandboxOriginEnumerator(const FilePath& base_path)
       : enumerator_(base_path, false /* recursive */,
                     file_util::FileEnumerator::DIRECTORIES) {}
   virtual ~OldSandboxOriginEnumerator() {}
 
   virtual GURL Next() OVERRIDE {
     current_ = enumerator_.Next();
     if (current_.empty())
       return GURL();
     return fileapi::GetOriginURLFromIdentifier(
-        FilePathStringToASCII(current_.BaseName().value()));
+        current_.BaseName().MaybeAsASCII());
   }
 
   virtual bool HasFileSystemType(fileapi::FileSystemType type) const OVERRIDE {
     if (current_.empty())
       return false;
-    std::string directory =
-        fileapi::FileSystemPathManager::GetFileSystemTypeString(type);
+    std::string directory = GetFileSystemTypeString(type);
     DCHECK(!directory.empty());
     return file_util::DirectoryExists(current_.AppendASCII(directory));
   }
 
  private:
   file_util::FileEnumerator enumerator_;
   FilePath current_;
 };
 
 FilePath OldGetBaseDirectoryForOrigin(
     const FilePath& old_base_path,
     const GURL& origin_url) {
   std::string id = fileapi::GetOriginIdentifierFromURL(origin_url);
   if (!id.empty())
     return old_base_path.AppendASCII(id);
   return FilePath();
 }
 
 FilePath OldGetBaseDirectoryForOriginAndType(
     const FilePath& old_base_path,
     const GURL& origin_url, fileapi::FileSystemType type) {
-  std::string type_string =
-      fileapi::FileSystemPathManager::GetFileSystemTypeString(type);
+  std::string type_string = GetFileSystemTypeString(type);
   if (type_string.empty()) {
     NOTREACHED();
     return FilePath();
   }
   FilePath base_path = OldGetBaseDirectoryForOrigin(
       old_base_path, origin_url);
   if (base_path.empty()) {
     NOTREACHED();
     return FilePath();
   }
@@ skipping 102 matching lines @@
 class SandboxMountPointProvider::GetFileSystemRootPathTask
     : public base::RefCountedThreadSafe<
         SandboxMountPointProvider::GetFileSystemRootPathTask> {
  public:
   GetFileSystemRootPathTask(
       scoped_refptr<base::MessageLoopProxy> file_message_loop,
       const GURL& origin_url,
       FileSystemType type,
       ObfuscatedFileUtil* file_util,
       const FilePath& old_base_path,
-      const FileSystemPathManager::GetRootPathCallback& callback)
+      const FileSystemMountPointProvider::GetRootPathCallback& callback)
       : file_message_loop_(file_message_loop),
         origin_message_loop_proxy_(
             base::MessageLoopProxy::current()),
         origin_url_(origin_url),
         type_(type),
         file_util_(file_util),
         old_base_path_(old_base_path),
         callback_(callback) {
   }
 
@@ skipping 28 matching lines @@
                                 kFileSystemErrorMax);
     }
     origin_message_loop_proxy_->PostTask(
         FROM_HERE,
         base::Bind(&GetFileSystemRootPathTask::DispatchCallback, this,
                    root_path));
   }
 
   void DispatchCallback(const FilePath& root_path) {
     std::string origin_identifier = GetOriginIdentifierFromURL(origin_url_);
-    std::string type_string =
-        FileSystemPathManager::GetFileSystemTypeString(type_);
+    std::string type_string = GetFileSystemTypeString(type_);
     DCHECK(!type_string.empty());
     std::string name = origin_identifier + ":" + type_string;
 
     if (!root_path.empty())
       UMA_HISTOGRAM_ENUMERATION(kOpenFileSystem, kOK, kFileSystemErrorMax);
 
     callback_.Run(!root_path.empty(), root_path, name);
     callback_.Reset();
   }
 
   scoped_refptr<base::MessageLoopProxy> file_message_loop_;
   scoped_refptr<base::MessageLoopProxy> origin_message_loop_proxy_;
   GURL origin_url_;
   FileSystemType type_;
   scoped_refptr<ObfuscatedFileUtil> file_util_;
   FilePath old_base_path_;
-  FileSystemPathManager::GetRootPathCallback callback_;
+  FileSystemMountPointProvider::GetRootPathCallback callback_;
 };
 
 SandboxMountPointProvider::SandboxMountPointProvider(
-    FileSystemPathManager* path_manager,
     scoped_refptr<base::MessageLoopProxy> file_message_loop,
-    const FilePath& profile_path)
+    const FilePath& profile_path,
+    const FileSystemOptions& file_system_options)
     : FileSystemQuotaUtil(file_message_loop),
-      path_manager_(path_manager),
       file_message_loop_(file_message_loop),
       profile_path_(profile_path),
+      file_system_options_(file_system_options),
       sandbox_file_util_(
           new ObfuscatedFileUtil(
               profile_path.Append(kNewFileSystemDirectory),
               QuotaFileUtil::CreateDefault())) {
 }
 
 SandboxMountPointProvider::~SandboxMountPointProvider() {
   if (!file_message_loop_->BelongsToCurrentThread())
     file_message_loop_->ReleaseSoon(FROM_HERE, sandbox_file_util_.release());
 }
 
 bool SandboxMountPointProvider::IsAccessAllowed(const GURL& origin_url,
                                                 FileSystemType type,
                                                 const FilePath& unused) {
   if (type != kFileSystemTypeTemporary && type != kFileSystemTypePersistent)
     return false;
-  // We essentially depend on quota to do our access controls.
-  return path_manager_->IsAllowedScheme(origin_url);
+  // We essentially depend on quota to do our access controls, so here
+  // we only check if the requested scheme is allowed or not.
+  return IsAllowedScheme(origin_url);
 }
 
 void SandboxMountPointProvider::ValidateFileSystemRootAndGetURL(
     const GURL& origin_url, fileapi::FileSystemType type, bool create,
-    const FileSystemPathManager::GetRootPathCallback& callback) {
+    const FileSystemMountPointProvider::GetRootPathCallback& callback) {
   FilePath origin_base_path;
 
-  if (path_manager_->is_incognito()) {
+  if (file_system_options_.is_incognito()) {
     // TODO(kinuko): return an isolated temporary directory.
     callback.Run(false, FilePath(), std::string());
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystem,
                               kIncognito,
                               kFileSystemErrorMax);
     return;
   }
 
-  if (!path_manager_->IsAllowedScheme(origin_url)) {
+  if (!IsAllowedScheme(origin_url)) {
     callback.Run(false, FilePath(), std::string());
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystem,
                               kInvalidScheme,
                               kFileSystemErrorMax);
     return;
   }
 
   scoped_refptr<GetFileSystemRootPathTask> task(
       new GetFileSystemRootPathTask(
           file_message_loop_, origin_url, type, sandbox_file_util_.get(),
           old_base_path(), callback));
   task->Start(create);
 };
 
 FilePath
 SandboxMountPointProvider::ValidateFileSystemRootAndGetPathOnFileThread(
     const GURL& origin_url, FileSystemType type, const FilePath& unused,
     bool create) {
-  if (path_manager_->is_incognito())
+  if (file_system_options_.is_incognito())
     // TODO(kinuko): return an isolated temporary directory.
     return FilePath();
 
-  if (!path_manager_->IsAllowedScheme(origin_url))
+  if (!IsAllowedScheme(origin_url))
     return FilePath();
 
   MigrateIfNeeded(sandbox_file_util_, old_base_path());
 
   return sandbox_file_util_->GetDirectoryForOriginAndType(
       origin_url, type, create);
 }
 
 bool SandboxMountPointProvider::IsRestrictedFileName(const FilePath& filename)
     const {
   if (filename.value().empty())
     return false;
 
-  std::string filename_lower = StringToLowerASCII(
-      FilePathStringToASCII(filename.value()));
-
   for (size_t i = 0; i < arraysize(kRestrictedNames); ++i) {
     // Exact match.
-    if (filename_lower == kRestrictedNames[i])
+    if (filename.value() == kRestrictedNames[i])
       return true;
   }
 
   for (size_t i = 0; i < arraysize(kRestrictedChars); ++i) {
     if (filename.value().find(kRestrictedChars[i]) !=
         FilePath::StringType::npos)
       return true;
   }
 
   return false;
@@ skipping 214 matching lines @@
     return FilePath();
 
   // Creates the root directory.
   root = origin_base_path.Append(OldCreateUniqueDirectoryName(origin_url));
   if (!file_util::CreateDirectory(root))
     return FilePath();
 
   return root;
 }
 
+bool SandboxMountPointProvider::IsAllowedScheme(const GURL& url) const {
+  // Basically we only accept http or https. We allow file:// URLs
+  // only if --allow-file-access-from-files flag is given.
+  if (url.SchemeIs("http") || url.SchemeIs("https"))
+    return true;
+  for (size_t i = 0;
+       i < file_system_options_.additional_allowed_schemes().size();
+       ++i) {
+    if (url.SchemeIs(
+            file_system_options_.additional_allowed_schemes()[i].c_str()))
+      return true;
+  }
+  return false;
+}
+
 }  // namespace fileapi