More filesystem cleanup: convert URL-encoded-as-FilePath to actual URL, where

webkit/fileapi/file_system_operation.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_operation.h"
 
 #include "base/time.h"
+#include "base/utf_string_conversions.h"
+#include "net/base/escape.h"
 #include "net/url_request/url_request_context.h"
 #include "webkit/fileapi/file_system_callback_dispatcher.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util_proxy.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/file_writer_delegate.h"
 #include "webkit/fileapi/local_file_system_file_util.h"
 
@@ skipping 38 matching lines @@
   // Also, in the future we won't need it either way, as long as we do all
   // permission+quota checks beforehand.  We only need it now because we have to
   // create an unpredictable directory name.  Without that, we could lazily
   // create the root later on the first filesystem write operation, and just
   // return GetFileSystemRootURI() here.
   file_system_context()->path_manager()->GetFileSystemRootPath(
       origin_url, type, create,
       callback_factory_.NewCallback(&FileSystemOperation::DidGetRootPath));
 }
 
-void FileSystemOperation::CreateFile(const FilePath& path,
+void FileSystemOperation::CreateFile(const GURL& path,
                                      bool exclusive) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationCreateFile;
 #endif
   FilePath virtual_path;
   GURL origin_url;
   FileSystemType type;
   if (!VerifyFileSystemPathForWrite(
       path, true /* create */, &origin_url, &type, &virtual_path)) {
     delete this;
     return;
   }
   file_system_operation_context_.set_src_origin_url(origin_url);
   file_system_operation_context_.set_src_type(type);
   FileSystemFileUtilProxy::EnsureFileExists(
       file_system_operation_context_,
       proxy_, virtual_path, callback_factory_.NewCallback(
           exclusive ? &FileSystemOperation::DidEnsureFileExistsExclusive
                     : &FileSystemOperation::DidEnsureFileExistsNonExclusive));
 }
 
-void FileSystemOperation::CreateDirectory(const FilePath& path,
+void FileSystemOperation::CreateDirectory(const GURL& path,
                                           bool exclusive,
                                           bool recursive) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationCreateDirectory;
 #endif
   FilePath virtual_path;
   GURL origin_url;
   FileSystemType type;
 
   if (!VerifyFileSystemPathForWrite(
       path, true /* create */, &origin_url, &type, &virtual_path)) {
     delete this;
     return;
   }
   file_system_operation_context_.set_src_origin_url(origin_url);
   file_system_operation_context_.set_src_type(type);
   FileSystemFileUtilProxy::CreateDirectory(
       file_system_operation_context_,
       proxy_, virtual_path, exclusive, recursive, callback_factory_.NewCallback(
           &FileSystemOperation::DidFinishFileOperation));
 }
 
-void FileSystemOperation::Copy(const FilePath& src_path,
-                               const FilePath& dest_path) {
+void FileSystemOperation::Copy(const GURL& src_path,
+                               const GURL& dest_path) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationCopy;
 #endif
   FilePath virtual_path_0;
   FilePath virtual_path_1;
   GURL src_origin_url;
   GURL dest_origin_url;
   FileSystemType src_type;
   FileSystemType dest_type;
@@ skipping 17 matching lines @@
   file_system_operation_context_.set_dest_origin_url(dest_origin_url);
   file_system_operation_context_.set_src_type(src_type);
   file_system_operation_context_.set_dest_type(dest_type);
   FileSystemFileUtilProxy::Copy(
       file_system_operation_context_,
       proxy_, virtual_path_0, virtual_path_1,
       callback_factory_.NewCallback(
         &FileSystemOperation::DidFinishFileOperation));
 }
 
-void FileSystemOperation::Move(const FilePath& src_path,
-                               const FilePath& dest_path) {
+void FileSystemOperation::Move(const GURL& src_path,
+                               const GURL& dest_path) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationMove;
 #endif
   FilePath virtual_path_0;
   FilePath virtual_path_1;
   GURL src_origin_url;
   GURL dest_origin_url;
   FileSystemType src_type;
   FileSystemType dest_type;
 
+  //TODO(ericu): Move alters the source path as well, so we should be checking
+  //both for write!
   if (!VerifyFileSystemPathForRead(src_path, &src_origin_url, &src_type,
         &virtual_path_0) ||
       !VerifyFileSystemPathForWrite(dest_path, true /* create */,
           &dest_origin_url, &dest_type, &virtual_path_1)) {
     delete this;
     return;
   }
   if (src_origin_url.GetOrigin() != dest_origin_url.GetOrigin()) {
     // TODO(ericu): We don't yet support moving across filesystem types, from
     // extension to sandbox, etc.  From temporary to persistent works, though.
     delete this;
     return;
   }
   file_system_operation_context_.set_src_origin_url(src_origin_url);
   file_system_operation_context_.set_dest_origin_url(dest_origin_url);
   file_system_operation_context_.set_src_type(src_type);
   file_system_operation_context_.set_dest_type(dest_type);
   FileSystemFileUtilProxy::Move(
       file_system_operation_context_,
       proxy_, virtual_path_0, virtual_path_1,
       callback_factory_.NewCallback(
         &FileSystemOperation::DidFinishFileOperation));
 }
 
-void FileSystemOperation::DirectoryExists(const FilePath& path) {
+void FileSystemOperation::DirectoryExists(const GURL& path) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationDirectoryExists;
 #endif
 
   FilePath virtual_path;
   GURL origin_url;
   FileSystemType type;
   if (!VerifyFileSystemPathForRead(path, &origin_url, &type, &virtual_path)) {
     delete this;
     return;
   }
   file_system_operation_context_.set_src_origin_url(origin_url);
   file_system_operation_context_.set_src_type(type);
   FileSystemFileUtilProxy::GetFileInfo(
       file_system_operation_context_,
       proxy_, virtual_path, callback_factory_.NewCallback(
           &FileSystemOperation::DidDirectoryExists));
 }
 
-void FileSystemOperation::FileExists(const FilePath& path) {
+void FileSystemOperation::FileExists(const GURL& path) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationFileExists;
 #endif
 
   FilePath virtual_path;
   GURL origin_url;
   FileSystemType type;
   if (!VerifyFileSystemPathForRead(path, &origin_url, &type, &virtual_path)) {
     delete this;
     return;
   }
   file_system_operation_context_.set_src_origin_url(origin_url);
   file_system_operation_context_.set_src_type(type);
   FileSystemFileUtilProxy::GetFileInfo(
       file_system_operation_context_,
       proxy_, virtual_path, callback_factory_.NewCallback(
           &FileSystemOperation::DidFileExists));
 }
 
-void FileSystemOperation::GetMetadata(const FilePath& path) {
+void FileSystemOperation::GetMetadata(const GURL& path) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationGetMetadata;
 #endif
 
   FilePath virtual_path;
   GURL origin_url;
   FileSystemType type;
   if (!VerifyFileSystemPathForRead(path, &origin_url, &type, &virtual_path)) {
     delete this;
     return;
   }
   file_system_operation_context_.set_src_origin_url(origin_url);
   file_system_operation_context_.set_src_type(type);
   FileSystemFileUtilProxy::GetFileInfo(
       file_system_operation_context_,
       proxy_, virtual_path, callback_factory_.NewCallback(
           &FileSystemOperation::DidGetMetadata));
 }
 
-void FileSystemOperation::ReadDirectory(const FilePath& path) {
+void FileSystemOperation::ReadDirectory(const GURL& path) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationReadDirectory;
 #endif
 
   FilePath virtual_path;
   GURL origin_url;
   FileSystemType type;
   if (!VerifyFileSystemPathForRead(path, &origin_url, &type, &virtual_path)) {
     delete this;
     return;
   }
   file_system_operation_context_.set_src_origin_url(origin_url);
   file_system_operation_context_.set_src_type(type);
   FileSystemFileUtilProxy::ReadDirectory(
       file_system_operation_context_,
       proxy_, virtual_path, callback_factory_.NewCallback(
           &FileSystemOperation::DidReadDirectory));
 }
 
-void FileSystemOperation::Remove(const FilePath& path, bool recursive) {
+void FileSystemOperation::Remove(const GURL& path, bool recursive) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationRemove;
 #endif
 
   FilePath virtual_path;
   GURL origin_url;
   FileSystemType type;
   if (!VerifyFileSystemPathForWrite(path, false /* create */, &origin_url,
       &type, &virtual_path)) {
     delete this;
     return;
   }
   file_system_operation_context_.set_src_origin_url(origin_url);
   file_system_operation_context_.set_src_type(type);
   FileSystemFileUtilProxy::Delete(
       file_system_operation_context_,
       proxy_, virtual_path, recursive, callback_factory_.NewCallback(
           &FileSystemOperation::DidFinishFileOperation));
 }
 
 void FileSystemOperation::Write(
     scoped_refptr<net::URLRequestContext> url_request_context,
-    const FilePath& path,
+    const GURL& path,
     const GURL& blob_url,
     int64 offset) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationWrite;
 #endif
   FilePath virtual_path;
   GURL origin_url;
   FileSystemType type;
   if (!VerifyFileSystemPathForWrite(path, true /* create */, &origin_url,
@@ skipping 11 matching lines @@
   FileSystemFileUtilProxy::CreateOrOpen(
       file_system_operation_context_,
       proxy_,
       virtual_path,
       base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE |
           base::PLATFORM_FILE_ASYNC,
       callback_factory_.NewCallback(
           &FileSystemOperation::OnFileOpenedForWrite));
 }
 
-void FileSystemOperation::Truncate(const FilePath& path, int64 length) {
+void FileSystemOperation::Truncate(const GURL& path, int64 length) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationTruncate;
 #endif
   FilePath virtual_path;
   GURL origin_url;
   FileSystemType type;
   if (!VerifyFileSystemPathForWrite(path, false /* create */, &origin_url,
       &type, &virtual_path)) {
     delete this;
     return;
   }
   file_system_operation_context_.set_src_origin_url(origin_url);
   file_system_operation_context_.set_src_type(type);
   FileSystemFileUtilProxy::Truncate(
       file_system_operation_context_,
       proxy_, virtual_path, length, callback_factory_.NewCallback(
           &FileSystemOperation::DidFinishFileOperation));
 }
 
-void FileSystemOperation::TouchFile(const FilePath& path,
+void FileSystemOperation::TouchFile(const GURL& path,
                                     const base::Time& last_access_time,
                                     const base::Time& last_modified_time) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationTouchFile;
 #endif
 
   FilePath virtual_path;
   GURL origin_url;
   FileSystemType type;
@@ skipping 40 matching lines @@
     // been cancelled, report it, and report that the cancel has succeeded.
     DCHECK(!cancel_operation_.get());
     cancel_operation_.swap(cancel_operation);
   }
 }
 
 void FileSystemOperation::DidGetRootPath(
     bool success,
     const FilePath& path, const std::string& name) {
   DCHECK(success || path.empty());
-  FilePath result;
+  GURL result;
   // We ignore the path, and return a URL instead.  The point was just to verify
   // that we could create/find the path.
   if (success) {
-    GURL root_url = GetFileSystemRootURI(
+    result = GetFileSystemRootURI(
         file_system_operation_context_.src_origin_url(),
         file_system_operation_context_.src_type());
-    result = FilePath().AppendASCII(root_url.spec());
   }
   dispatcher_->DidOpenFileSystem(name, result);
   delete this;
 }
 
 void FileSystemOperation::DidEnsureFileExistsExclusive(
     base::PlatformFileError rv, bool created) {
   if (rv == base::PLATFORM_FILE_OK && !created) {
     dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_EXISTS);
     delete this;
@@ skipping 101 matching lines @@
     bool created) {
   if (base::PLATFORM_FILE_OK != rv) {
     dispatcher_->DidFail(rv);
     delete this;
     return;
   }
   file_writer_delegate_->Start(file.ReleaseValue(), blob_request_.get());
 }
 
 bool FileSystemOperation::VerifyFileSystemPathForRead(
-    const FilePath& path, GURL* origin_url, FileSystemType* type,
+    const GURL& path, GURL* origin_url, FileSystemType* type,
     FilePath* virtual_path) {
 
   // If we have no context, we just allow any operations, for testing.
   // TODO(ericu): Revisit this hack for security.
   if (!file_system_context()) {
-    *virtual_path = path;
+#ifdef OS_WIN
+    // On Windows, the path will look like /C:/foo/bar; we need to remove the
+    // leading slash to make it valid.  But if it's empty, we shouldn't do
+    // anything.
+    std::string temp = UnescapeURLComponent(path.path(),
+        UnescapeRule::SPACES | UnescapeRule::URL_SPECIAL_CHARS);
+    if (temp.size())
+      temp = temp.substr(1);
+    *virtual_path = FilePath(UTF8ToWide(temp)).NormalizeWindowsPathSeparators();
+#else
+    *virtual_path = FilePath(path.path());
+#endif
     *type = file_system_operation_context_.src_type();
+    *origin_url = file_system_operation_context_.src_origin_url();
     return true;
   }
 
   // We may want do more checks, but for now it just checks if the given
-  // |path| is under the valid FileSystem root path for this host context.
-  if (!file_system_context()->path_manager()->CrackFileSystemPath(
-          path, origin_url, type, virtual_path)) {
+  // URL is valid.
+  if (!CrackFileSystemURL(path, origin_url, type, virtual_path)) {
+    dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
+    return false;
+  }
+  if (!file_system_context()->path_manager()->IsAllowedFileSystemType(
+      *origin_url, *type)) {
     dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
     return false;
   }
 
   return true;
 }
 
 bool FileSystemOperation::VerifyFileSystemPathForWrite(
-    const FilePath& path, bool create, GURL* origin_url, FileSystemType* type,
+    const GURL& path, bool create, GURL* origin_url, FileSystemType* type,
     FilePath* virtual_path) {
 
   // If we have no context, we just allow any operations, for testing.
   // TODO(ericu): Revisit this hack for security.
   if (!file_system_context()) {
-    *virtual_path = path;
+#ifdef OS_WIN
+    // On Windows, the path will look like /C:/foo/bar; we need to remove the
+    // leading slash to make it valid.  But if it's empty, we shouldn't do
+    // anything.
+    std::string temp = UnescapeURLComponent(path.path(),
+        UnescapeRule::SPACES | UnescapeRule::URL_SPECIAL_CHARS);
+    if (temp.size())
+      temp = temp.substr(1);
+    *virtual_path = FilePath(UTF8ToWide(temp)).NormalizeWindowsPathSeparators();
+#else
+    *virtual_path = FilePath(path.path());
+#endif
     *type = file_system_operation_context_.dest_type();
+    *origin_url = file_system_operation_context_.dest_origin_url();
     return true;
   }
 
-  if (!file_system_context()->path_manager()->CrackFileSystemPath(
-          path, origin_url, type, virtual_path)) {
+  if (!CrackFileSystemURL(path, origin_url, type, virtual_path)) {
+    dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
+    return false;
+  }
+  if (!file_system_context()->path_manager()->IsAllowedFileSystemType(
+      *origin_url, *type)) {
     dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
     return false;
   }
   // Any write access is disallowed on the root path.
   if (virtual_path->value().length() == 0 ||
       virtual_path->DirName().value() == virtual_path->value()) {
     dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
     return false;
   }
   if (create && file_system_context()->path_manager()->IsRestrictedFileName(
           *type, virtual_path->BaseName())) {
     dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
     return false;
   }
   // TODO(kinuko): the check must be moved to QuotaFileSystemFileUtil.
   if (!file_system_context()->IsStorageUnlimited(*origin_url)) {
     dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_NO_SPACE);
     return false;
   }
   return true;
 }
 
 }  // namespace fileapi