File API changes needed for safely passing user selected file entities from the file browser comp...

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/logging.h"
 #include "base/memory/scoped_callback_factory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
@@ skipping 93 matching lines @@
   return root;
 }
 
 }  // anonymous namespace
 
 namespace fileapi {
 
 const FilePath::CharType SandboxMountPointProvider::kFileSystemDirectory[] =
     FILE_PATH_LITERAL("FileSystem");
 
-const char SandboxMountPointProvider::kPersistentName[] = "Persistent";
-const char SandboxMountPointProvider::kTemporaryName[] = "Temporary";
-
 SandboxMountPointProvider::SandboxMountPointProvider(
     FileSystemPathManager* path_manager,
     scoped_refptr<base::MessageLoopProxy> file_message_loop,
     const FilePath& profile_path)
     : path_manager_(path_manager),
       file_message_loop_(file_message_loop),
       base_path_(profile_path.Append(kFileSystemDirectory)) {
 }
 
 SandboxMountPointProvider::~SandboxMountPointProvider() {
 }
 
-bool SandboxMountPointProvider::IsAccessAllowed(const GURL& origin_url) {
+bool SandboxMountPointProvider::IsAccessAllowed(const GURL& origin_url,
+                                                const FilePath& unused) {
   // We essentially depend on quota to do our access controls.
   return path_manager_->IsAllowedScheme(origin_url);
 }
 
 class SandboxMountPointProvider::GetFileSystemRootPathTask
     : public base::RefCountedThreadSafe<
         SandboxMountPointProvider::GetFileSystemRootPathTask> {
  public:
   GetFileSystemRootPathTask(
       scoped_refptr<base::MessageLoopProxy> file_message_loop,
@@ skipping 64 matching lines @@
 
   for (size_t i = 0; i < arraysize(kRestrictedChars); ++i) {
     if (filename.value().find(kRestrictedChars[i]) !=
         FilePath::StringType::npos)
       return true;
   }
 
   return false;
 }
 
+std::vector<FilePath> SandboxMountPointProvider::GetRootDirectories() const {
+  NOTREACHED();
+  // TODO(ericu): Implement this method and check for access permissions as
+  // fileBrowserPrivate extension API does. We currently have another mechanism,
+  // but we should switch over.
+  return  std::vector<FilePath>();
+}
+
 void SandboxMountPointProvider::GetFileSystemRootPath(
     const GURL& origin_url, fileapi::FileSystemType type,
     bool create, FileSystemPathManager::GetRootPathCallback* callback_ptr) {
   scoped_ptr<FileSystemPathManager::GetRootPathCallback> callback(callback_ptr);
   std::string name;
   FilePath origin_base_path;
 
   if (!GetOriginBasePathAndName(origin_url, &origin_base_path, type, &name)) {
     callback->Run(false, FilePath(), std::string());
     return;
@@ skipping 47 matching lines @@
                   file_util::FileEnumerator::DIRECTORIES) {
 }
 
 std::string SandboxMountPointProvider::OriginEnumerator::Next() {
   current_ = enumerator_.Next();
   return FilePathStringToASCII(current_.BaseName().value());
 }
 
 bool SandboxMountPointProvider::OriginEnumerator::HasTemporary() {
   return !current_.empty() && file_util::DirectoryExists(current_.AppendASCII(
-      SandboxMountPointProvider::kTemporaryName));
+      fileapi::kTemporaryName));
 }
 
 bool SandboxMountPointProvider::OriginEnumerator::HasPersistent() {
   return !current_.empty() && file_util::DirectoryExists(current_.AppendASCII(
-      SandboxMountPointProvider::kPersistentName));
+      fileapi::kPersistentName));
 }
 
 bool SandboxMountPointProvider::GetOriginBasePathAndName(
     const GURL& origin_url,
     FilePath* origin_base_path,
     FileSystemType type,
     std::string* name) {
 
   if (path_manager_->is_incognito())
     // TODO(kinuko): return an isolated temporary directory.
@@ skipping 10 matching lines @@
 
   std::string type_string =
       FileSystemPathManager::GetFileSystemTypeString(type);
   DCHECK(!type_string.empty());
   if (name)
     *name = origin_identifier + ":" + type_string;
   return true;
 }
 
 }  // namespace fileapi