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

webkit/fileapi/file_system_path_manager.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/file_system_path_manager.h"
 
 #include "base/rand_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_callback_factory.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 29 matching lines @@
     bool is_incognito,
     bool allow_file_access_from_files)
     : is_incognito_(is_incognito),
       allow_file_access_from_files_(allow_file_access_from_files),
       sandbox_provider_(
           new SandboxMountPointProvider(
               ALLOW_THIS_IN_INITIALIZER_LIST(this),
               file_message_loop,
               profile_path)) {
 #if defined(OS_CHROMEOS)
-  local_provider_.reset(
+  external_provider_.reset(
       new chromeos::CrosMountPointProvider(special_storage_policy));
 #endif
 }
 
 FileSystemPathManager::~FileSystemPathManager() {}
 
 void FileSystemPathManager::GetFileSystemRootPath(
     const GURL& origin_url, fileapi::FileSystemType type,
     bool create, GetRootPathCallback* callback_ptr) {
 
   switch (type) {
   case kFileSystemTypeTemporary:
   case kFileSystemTypePersistent:
     sandbox_provider_->GetFileSystemRootPath(
         origin_url, type, create, callback_ptr);
     break;
-  case kFileSystemTypeLocal:
-    if (local_provider_.get()) {
-      local_provider_->GetFileSystemRootPath(
+  case kFileSystemTypeExternal:
+    if (external_provider_.get()) {
+      external_provider_->GetFileSystemRootPath(
           origin_url, type, create, callback_ptr);
     } else {
       callback_ptr->Run(false, FilePath(), std::string());
     }
     break;
   case kFileSystemTypeUnknown:
   default:
     NOTREACHED();
     callback_ptr->Run(false, FilePath(), std::string());
   }
 }
 
 FilePath FileSystemPathManager::GetFileSystemRootPathOnFileThread(
     const GURL& origin_url, FileSystemType type, const FilePath& virtual_path,
     bool create) {
   switch (type) {
   case kFileSystemTypeTemporary:
   case kFileSystemTypePersistent:
     return sandbox_provider_->GetFileSystemRootPathOnFileThread(
         origin_url, type, virtual_path, create);
     break;
-  case kFileSystemTypeLocal:
-    return local_provider_.get() ?
-        local_provider_->GetFileSystemRootPathOnFileThread(
+  case kFileSystemTypeExternal:
+    return external_provider_.get() ?
+        external_provider_->GetFileSystemRootPathOnFileThread(
            origin_url, type, virtual_path, create) :
         FilePath();
   case kFileSystemTypeUnknown:
   default:
     NOTREACHED();
     return FilePath();
   }
 }
 
 bool FileSystemPathManager::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.
   return url.SchemeIs("http") || url.SchemeIs("https") ||
          url.SchemeIs(kExtensionScheme) ||
          (url.SchemeIsFile() && allow_file_access_from_files_);
 }
 
 // static
 std::string FileSystemPathManager::GetFileSystemTypeString(
     fileapi::FileSystemType type) {
   if (type == fileapi::kFileSystemTypeTemporary)
     return fileapi::SandboxMountPointProvider::kTemporaryName;
   else if (type == fileapi::kFileSystemTypePersistent)
     return fileapi::SandboxMountPointProvider::kPersistentName;
+  else if (type == fileapi::kFileSystemTypeExternal)
+    return fileapi::SandboxMountPointProvider::kExternalName;
   return std::string();
 }
 
 // Checks if a given |name| contains any restricted names/chars in it.
 bool FileSystemPathManager::IsRestrictedFileName(
     FileSystemType type, const FilePath& filename) {
   switch (type) {
   case kFileSystemTypeTemporary:
   case kFileSystemTypePersistent:
     return sandbox_provider_->IsRestrictedFileName(filename);
-  case kFileSystemTypeLocal:
-    return local_provider_.get() ?
-               local_provider_->IsRestrictedFileName(filename) : true;
+  case kFileSystemTypeExternal:
+    return external_provider_.get() ?
+               external_provider_->IsRestrictedFileName(filename) : true;
   case kFileSystemTypeUnknown:
   default:
     NOTREACHED();
     return true;
   }
 }
 
 // Checks if an origin has access to a particular filesystem type.
 bool FileSystemPathManager::IsAllowedFileSystemType(
-    GURL origin, FileSystemType type) {
+    const GURL& origin, FileSystemType type, const FilePath& virtual_path) {
   switch (type) {
     case kFileSystemTypeTemporary:
     case kFileSystemTypePersistent:
-      if (!sandbox_provider_->IsAccessAllowed(origin))
+      if (!sandbox_provider_->IsAccessAllowed(origin, virtual_path))
         return false;
       break;
-    case kFileSystemTypeLocal:
-      if (!local_provider_.get() ||
-          !local_provider_->IsAccessAllowed(origin)) {
+    case kFileSystemTypeExternal:
+      if (!external_provider_.get() ||
+          !external_provider_->IsAccessAllowed(origin, virtual_path)) {
         return false;
       }
       break;
     case kFileSystemTypeUnknown:
     default:
       NOTREACHED();
       return false;
   }
   return true;
 }
 
 }  // namespace fileapi
 
 COMPILE_ASSERT(int(WebFileSystem::TypeTemporary) == \
                int(fileapi::kFileSystemTypeTemporary), mismatching_enums);
 COMPILE_ASSERT(int(WebFileSystem::TypePersistent) == \
                int(fileapi::kFileSystemTypePersistent), mismatching_enums);
+COMPILE_ASSERT(int(WebFileSystem::TypeExternal) == \
+               int(fileapi::kFileSystemTypeExternal), mismatching_enums);