From 08f8feb39b2c8801dd39a1531fb5958644162e6d Mon Sep 17 00:00:00 2001 From: "kinuko@chromium.org" Date: Sun, 26 Feb 2012 11:53:50 +0000 Subject: Move src/dest info out of FileSystemOperationContext Current FileSystemOperationContext has both src and dest path file info in it but this is making the code for cross-FileUtil operations way complex. This patch removes src/dest information from FileSystemOperationContext and instead: - introduce new FileSystemPath class, which represents a file path information in a filesystem - replace all the FilePath args in FileSystemFileUtil with FileSystemPath The resulting code still has some ugly part, and if we get rid of cross-FU operations from each FU code eventually we may end up converting FileSystemPath back to FilePath, but I think this change is not far from the way we want to go. BUG=114732, 110121 TEST=existing tests Review URL: http://codereview.chromium.org/9413009 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@123689 0039d316-1c4b-4281-b951-d872f2087c98 --- .../file_system_dir_url_request_job_unittest.cc | 34 +- webkit/fileapi/file_system_file_util.cc | 277 +++++++------- webkit/fileapi/file_system_file_util.h | 99 ++--- webkit/fileapi/file_system_file_util_unittest.cc | 26 +- webkit/fileapi/file_system_mount_point_provider.h | 2 +- webkit/fileapi/file_system_operation.cc | 362 +++++++++--------- webkit/fileapi/file_system_operation.h | 115 ++---- webkit/fileapi/file_system_operation_context.cc | 26 +- webkit/fileapi/file_system_operation_context.h | 73 +--- webkit/fileapi/file_system_operation_unittest.cc | 3 +- webkit/fileapi/file_system_path.cc | 40 ++ webkit/fileapi/file_system_path.h | 94 +++++ .../fileapi/file_system_quota_client_unittest.cc | 40 +- webkit/fileapi/file_system_test_helper.cc | 21 +- webkit/fileapi/file_system_test_helper.h | 9 +- .../file_system_url_request_job_unittest.cc | 20 +- webkit/fileapi/file_writer_delegate.cc | 37 +- webkit/fileapi/file_writer_delegate.h | 3 + webkit/fileapi/file_writer_delegate_unittest.cc | 2 + webkit/fileapi/local_file_util.cc | 168 ++++----- webkit/fileapi/local_file_util.h | 51 ++- webkit/fileapi/local_file_util_unittest.cc | 4 +- webkit/fileapi/native_file_util.cc | 122 +++--- webkit/fileapi/native_file_util.h | 42 +-- webkit/fileapi/obfuscated_file_util.cc | 414 +++++++++++---------- webkit/fileapi/obfuscated_file_util.h | 83 +++-- webkit/fileapi/obfuscated_file_util_unittest.cc | 233 ++++++------ webkit/fileapi/quota_file_util.cc | 41 +- webkit/fileapi/quota_file_util.h | 10 +- webkit/fileapi/quota_file_util_unittest.cc | 4 +- webkit/fileapi/sandbox_mount_point_provider.cc | 7 +- .../sandbox_mount_point_provider_unittest.cc | 47 ++- webkit/fileapi/webkit_fileapi.gypi | 2 + 33 files changed, 1247 insertions(+), 1264 deletions(-) create mode 100644 webkit/fileapi/file_system_path.cc create mode 100644 webkit/fileapi/file_system_path.h diff --git a/webkit/fileapi/file_system_dir_url_request_job_unittest.cc b/webkit/fileapi/file_system_dir_url_request_job_unittest.cc index a329092..f0459ba 100644 --- a/webkit/fileapi/file_system_dir_url_request_job_unittest.cc +++ b/webkit/fileapi/file_system_dir_url_request_job_unittest.cc @@ -32,6 +32,7 @@ #include "webkit/fileapi/file_system_context.h" #include "webkit/fileapi/file_system_file_util.h" #include "webkit/fileapi/file_system_operation_context.h" +#include "webkit/fileapi/file_system_path.h" #include "webkit/fileapi/mock_file_system_options.h" #include "webkit/fileapi/sandbox_mount_point_provider.h" #include "webkit/quota/mock_special_storage_policy.h" @@ -110,45 +111,50 @@ class FileSystemDirURLRequestJobTest : public testing::Test { TestRequestHelper(url, false); } - FileSystemOperationContext* NewOperationContext(const FilePath& path) { - FileSystemOperationContext* context(new FileSystemOperationContext( - file_system_context_, file_util())); + FileSystemPath CreatePath(const FilePath& file_path) { + return FileSystemPath(GURL("http://remote"), + fileapi::kFileSystemTypeTemporary, + file_path, + file_util()); + } - context->set_src_origin_url(GURL("http://remote")); - context->set_src_type(fileapi::kFileSystemTypeTemporary); + FileSystemOperationContext* NewOperationContext() { + FileSystemOperationContext* context(new FileSystemOperationContext( + file_system_context_)); context->set_allowed_bytes_growth(1024); return context; } - void CreateDirectory(const base::StringPiece dir_name) { + void CreateDirectory(const base::StringPiece& dir_name) { FilePath path = FilePath().AppendASCII(dir_name); - scoped_ptr context(NewOperationContext(path)); + scoped_ptr context(NewOperationContext()); ASSERT_EQ(base::PLATFORM_FILE_OK, file_util()->CreateDirectory( context.get(), - path, + CreatePath(path), false /* exclusive */, false /* recursive */)); } void EnsureFileExists(const base::StringPiece file_name) { FilePath path = FilePath().AppendASCII(file_name); - scoped_ptr context(NewOperationContext(path)); + scoped_ptr context(NewOperationContext()); ASSERT_EQ(base::PLATFORM_FILE_OK, file_util()->EnsureFileExists( - context.get(), path, NULL)); + context.get(), CreatePath(path), NULL)); } void TruncateFile(const base::StringPiece file_name, int64 length) { FilePath path = FilePath().AppendASCII(file_name); - scoped_ptr context(NewOperationContext(path)); + scoped_ptr context(NewOperationContext()); ASSERT_EQ(base::PLATFORM_FILE_OK, file_util()->Truncate( - context.get(), path, length)); + context.get(), CreatePath(path), length)); } PlatformFileError GetFileInfo(const FilePath& path, base::PlatformFileInfo* file_info, FilePath* platform_file_path) { - scoped_ptr context(NewOperationContext(path)); - return file_util()->GetFileInfo(context.get(), path, + scoped_ptr context(NewOperationContext()); + return file_util()->GetFileInfo(context.get(), + CreatePath(path), file_info, platform_file_path); } diff --git a/webkit/fileapi/file_system_file_util.cc b/webkit/fileapi/file_system_file_util.cc index 5daa6a6..9156075 100644 --- a/webkit/fileapi/file_system_file_util.cc +++ b/webkit/fileapi/file_system_file_util.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 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. @@ -7,6 +7,7 @@ #include #include "base/memory/scoped_ptr.h" +#include "webkit/fileapi/file_system_context.h" #include "webkit/fileapi/file_system_operation_context.h" namespace fileapi { @@ -15,13 +16,14 @@ namespace { // This assumes that the root exists. bool ParentExists(FileSystemOperationContext* context, - FileSystemFileUtil* file_util, const FilePath& file_path) { - // If file_path is in the root, file_path.DirName() will be ".", + const FileSystemPath& path) { + // If path is in the root, path.DirName() will be ".", // since we use paths with no leading '/'. - FilePath parent = file_path.DirName(); + FilePath parent = path.internal_path().DirName(); if (parent == FilePath(FILE_PATH_LITERAL("."))) return true; - return file_util->DirectoryExists(context, parent); + return path.file_util()->DirectoryExists( + context, path.WithInternalPath(parent)); } } // namespace @@ -38,62 +40,62 @@ FileSystemFileUtil::~FileSystemFileUtil() { PlatformFileError FileSystemFileUtil::Copy( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path) { + const FileSystemPath& src_path, + const FileSystemPath& dest_path) { PlatformFileError error_code; error_code = PerformCommonCheckAndPreparationForMoveAndCopy( - context, src_file_path, dest_file_path); + context, src_path, dest_path); if (error_code != base::PLATFORM_FILE_OK) return error_code; - if (DirectoryExists(context, src_file_path)) - return CopyOrMoveDirectory(context, src_file_path, dest_file_path, + if (DirectoryExists(context, src_path)) + return CopyOrMoveDirectory(context, src_path, dest_path, true /* copy */); - return CopyOrMoveFileHelper(context, src_file_path, dest_file_path, + return CopyOrMoveFileHelper(context, src_path, dest_path, true /* copy */); } PlatformFileError FileSystemFileUtil::Move( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path) { + const FileSystemPath& src_path, + const FileSystemPath& dest_path) { PlatformFileError error_code; error_code = PerformCommonCheckAndPreparationForMoveAndCopy( - context, src_file_path, dest_file_path); + context, src_path, dest_path); if (error_code != base::PLATFORM_FILE_OK) return error_code; // TODO(dmikurube): ReplaceFile if in the same domain and filesystem type. - if (DirectoryExists(context, src_file_path)) - return CopyOrMoveDirectory(context, src_file_path, dest_file_path, + if (DirectoryExists(context, src_path)) + return CopyOrMoveDirectory(context, src_path, dest_path, false /* copy */); - return CopyOrMoveFileHelper(context, src_file_path, dest_file_path, + return CopyOrMoveFileHelper(context, src_path, dest_path, false /* copy */); } PlatformFileError FileSystemFileUtil::Delete( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, bool recursive) { - if (DirectoryExists(context, file_path)) { + if (DirectoryExists(context, path)) { if (!recursive) - return DeleteSingleDirectory(context, file_path); + return DeleteSingleDirectory(context, path); else - return DeleteDirectoryRecursive(context, file_path); + return DeleteDirectoryRecursive(context, path); } else { - return DeleteFile(context, file_path); + return DeleteFile(context, path); } } PlatformFileError FileSystemFileUtil::CreateOrOpen( FileSystemOperationContext* context, - const FilePath& file_path, int file_flags, + const FileSystemPath& path, int file_flags, PlatformFile* file_handle, bool* created) { if (underlying_file_util_.get()) { return underlying_file_util_->CreateOrOpen( - context, file_path, file_flags, file_handle, created); + context, path, file_flags, file_handle, created); } NOTREACHED() << "Subclasses must provide implementation if they have no" << "underlying_file_util"; @@ -113,10 +115,10 @@ PlatformFileError FileSystemFileUtil::Close( PlatformFileError FileSystemFileUtil::EnsureFileExists( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, bool* created) { if (underlying_file_util_.get()) { - return underlying_file_util_->EnsureFileExists(context, file_path, created); + return underlying_file_util_->EnsureFileExists(context, path, created); } NOTREACHED() << "Subclasses must provide implementation if they have no" << "underlying_file_util"; @@ -125,12 +127,12 @@ PlatformFileError FileSystemFileUtil::EnsureFileExists( PlatformFileError FileSystemFileUtil::CreateDirectory( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, bool exclusive, bool recursive) { if (underlying_file_util_.get()) { return underlying_file_util_->CreateDirectory( - context, file_path, exclusive, recursive); + context, path, exclusive, recursive); } NOTREACHED() << "Subclasses must provide implementation if they have no" << "underlying_file_util"; @@ -139,12 +141,12 @@ PlatformFileError FileSystemFileUtil::CreateDirectory( PlatformFileError FileSystemFileUtil::GetFileInfo( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, base::PlatformFileInfo* file_info, FilePath* platform_file_path) { if (underlying_file_util_.get()) { return underlying_file_util_->GetFileInfo( - context, file_path, file_info, platform_file_path); + context, path, file_info, platform_file_path); } NOTREACHED() << "Subclasses must provide implementation if they have no" << "underlying_file_util"; @@ -153,10 +155,10 @@ PlatformFileError FileSystemFileUtil::GetFileInfo( PlatformFileError FileSystemFileUtil::ReadDirectory( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, std::vector* entries) { if (underlying_file_util_.get()) { - return underlying_file_util_->ReadDirectory(context, file_path, entries); + return underlying_file_util_->ReadDirectory(context, path, entries); } NOTREACHED() << "Subclasses must provide implementation if they have no" << "underlying_file_util"; @@ -166,7 +168,7 @@ PlatformFileError FileSystemFileUtil::ReadDirectory( FileSystemFileUtil::AbstractFileEnumerator* FileSystemFileUtil::CreateFileEnumerator( FileSystemOperationContext* context, - const FilePath& root_path) { + const FileSystemPath& root_path) { if (underlying_file_util_.get()) { return underlying_file_util_->CreateFileEnumerator(context, root_path); } @@ -177,11 +179,11 @@ FileSystemFileUtil::CreateFileEnumerator( PlatformFileError FileSystemFileUtil::GetLocalFilePath( FileSystemOperationContext* context, - const FilePath& virtual_path, - FilePath* local_path) { + const FileSystemPath& file_system_path, + FilePath* local_file_path) { if (underlying_file_util_.get()) { return underlying_file_util_->GetLocalFilePath( - context, virtual_path, local_path); + context, file_system_path, local_file_path); } NOTREACHED() << "Subclasses must provide implementation if they have no" << "underlying_file_util"; @@ -190,12 +192,12 @@ PlatformFileError FileSystemFileUtil::GetLocalFilePath( PlatformFileError FileSystemFileUtil::Touch( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, const base::Time& last_access_time, const base::Time& last_modified_time) { if (underlying_file_util_.get()) { return underlying_file_util_->Touch( - context, file_path, last_access_time, last_modified_time); + context, path, last_access_time, last_modified_time); } NOTREACHED() << "Subclasses must provide implementation if they have no" << "underlying_file_util"; @@ -204,10 +206,10 @@ PlatformFileError FileSystemFileUtil::Touch( PlatformFileError FileSystemFileUtil::Truncate( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, int64 length) { if (underlying_file_util_.get()) { - return underlying_file_util_->Truncate(context, file_path, length); + return underlying_file_util_->Truncate(context, path, length); } NOTREACHED() << "Subclasses must provide implementation if they have no" << "underlying_file_util"; @@ -217,9 +219,9 @@ PlatformFileError FileSystemFileUtil::Truncate( bool FileSystemFileUtil::PathExists( FileSystemOperationContext* context, - const FilePath& file_path) { + const FileSystemPath& path) { if (underlying_file_util_.get()) { - return underlying_file_util_->PathExists(context, file_path); + return underlying_file_util_->PathExists(context, path); } NOTREACHED() << "Subclasses must provide implementation if they have no" << "underlying_file_util"; @@ -228,9 +230,9 @@ bool FileSystemFileUtil::PathExists( bool FileSystemFileUtil::DirectoryExists( FileSystemOperationContext* context, - const FilePath& file_path) { + const FileSystemPath& path) { if (underlying_file_util_.get()) { - return underlying_file_util_->DirectoryExists(context, file_path); + return underlying_file_util_->DirectoryExists(context, path); } NOTREACHED() << "Subclasses must provide implementation if they have no" << "underlying_file_util"; @@ -239,9 +241,9 @@ bool FileSystemFileUtil::DirectoryExists( bool FileSystemFileUtil::IsDirectoryEmpty( FileSystemOperationContext* context, - const FilePath& file_path) { + const FileSystemPath& path) { if (underlying_file_util_.get()) { - return underlying_file_util_->IsDirectoryEmpty(context, file_path); + return underlying_file_util_->IsDirectoryEmpty(context, path); } NOTREACHED() << "Subclasses must provide implementation if they have no" << "underlying_file_util"; @@ -250,12 +252,12 @@ bool FileSystemFileUtil::IsDirectoryEmpty( PlatformFileError FileSystemFileUtil::CopyOrMoveFile( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path, + const FileSystemPath& src_path, + const FileSystemPath& dest_path, bool copy) { if (underlying_file_util_.get()) { return underlying_file_util_->CopyOrMoveFile( - context, src_file_path, dest_file_path, copy); + context, src_path, dest_path, copy); } NOTREACHED() << "Subclasses must provide implementation if they have no" << "underlying_file_util"; @@ -264,11 +266,11 @@ PlatformFileError FileSystemFileUtil::CopyOrMoveFile( PlatformFileError FileSystemFileUtil::CopyInForeignFile( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path) { + const FileSystemPath& underlying_src_path, + const FileSystemPath& dest_path) { if (underlying_file_util_.get()) { return underlying_file_util_->CopyInForeignFile( - context, src_file_path, dest_file_path); + context, underlying_src_path, dest_path); } NOTREACHED() << "Subclasses must provide implementation if they have no" << "underlying_file_util"; @@ -277,9 +279,9 @@ PlatformFileError FileSystemFileUtil::CopyInForeignFile( PlatformFileError FileSystemFileUtil::DeleteFile( FileSystemOperationContext* context, - const FilePath& file_path) { + const FileSystemPath& path) { if (underlying_file_util_.get()) { - return underlying_file_util_->DeleteFile(context, file_path); + return underlying_file_util_->DeleteFile(context, path); } NOTREACHED() << "Subclasses must provide implementation if they have no" << "underlying_file_util"; @@ -288,9 +290,9 @@ PlatformFileError FileSystemFileUtil::DeleteFile( PlatformFileError FileSystemFileUtil::DeleteSingleDirectory( FileSystemOperationContext* context, - const FilePath& file_path) { + const FileSystemPath& path) { if (underlying_file_util_.get()) { - return underlying_file_util_->DeleteSingleDirectory(context, file_path); + return underlying_file_util_->DeleteSingleDirectory(context, path); } NOTREACHED() << "Subclasses must provide implementation if they have no" << "underlying_file_util"; @@ -300,59 +302,47 @@ PlatformFileError FileSystemFileUtil::DeleteSingleDirectory( PlatformFileError FileSystemFileUtil::PerformCommonCheckAndPreparationForMoveAndCopy( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path) { - bool same_file_system = - (context->src_origin_url() == context->dest_origin_url()) && - (context->src_type() == context->dest_type()); - FileSystemFileUtil* dest_util = context->dest_file_util(); - DCHECK(dest_util); - scoped_ptr local_dest_context; - FileSystemOperationContext* dest_context = NULL; - if (same_file_system) { - dest_context = context; - DCHECK(context->src_file_util() == context->dest_file_util()); - } else { - local_dest_context.reset(context->CreateInheritedContextForDest()); - // All the single-path virtual FSFU methods expect the context information - // to be in the src_* variables, not the dest_* variables, so we have to - // make a new context if we want to call them on the dest_file_path. - dest_context = local_dest_context.get(); - } - + const FileSystemPath& src_path, + const FileSystemPath& dest_path) { // Exits earlier if the source path does not exist. - if (!PathExists(context, src_file_path)) + if (!PathExists(context, src_path)) return base::PLATFORM_FILE_ERROR_NOT_FOUND; - // The parent of the |dest_file_path| does not exist. - if (!ParentExists(dest_context, dest_util, dest_file_path)) + // It is an error to copy/move an entry into the same path. + if (src_path == dest_path) + return base::PLATFORM_FILE_ERROR_EXISTS; + + bool same_file_system = + (src_path.origin() == dest_path.origin()) && + (src_path.type() == dest_path.type()); + FileSystemFileUtil* dest_util = dest_path.file_util(); + DCHECK(dest_util); + + // The parent of the |dest_path| does not exist. + if (!ParentExists(context, dest_path)) return base::PLATFORM_FILE_ERROR_NOT_FOUND; // It is an error to try to copy/move an entry into its child. - if (same_file_system && src_file_path.IsParent(dest_file_path)) + if (same_file_system && src_path.IsParent(dest_path)) return base::PLATFORM_FILE_ERROR_INVALID_OPERATION; - // Now it is ok to return if the |dest_file_path| does not exist. - if (!dest_util->PathExists(dest_context, dest_file_path)) + // Now it is ok to return if the |dest_path| does not exist. + if (!dest_util->PathExists(context, dest_path)) return base::PLATFORM_FILE_OK; - // |src_file_path| exists and is a directory. - // |dest_file_path| exists and is a file. - bool src_is_directory = DirectoryExists(context, src_file_path); + // |src_path| exists and is a directory. + // |dest_path| exists and is a file. + bool src_is_directory = DirectoryExists(context, src_path); bool dest_is_directory = - dest_util->DirectoryExists(dest_context, dest_file_path); + dest_util->DirectoryExists(context, dest_path); if (src_is_directory && !dest_is_directory) return base::PLATFORM_FILE_ERROR_INVALID_OPERATION; - // |src_file_path| exists and is a file. - // |dest_file_path| exists and is a directory. + // |src_path| exists and is a file. + // |dest_path| exists and is a directory. if (!src_is_directory && dest_is_directory) return base::PLATFORM_FILE_ERROR_INVALID_OPERATION; - // It is an error to copy/move an entry into the same path. - if (same_file_system && (src_file_path.value() == dest_file_path.value())) - return base::PLATFORM_FILE_ERROR_EXISTS; - if (dest_is_directory) { // It is an error to copy/move an entry to a non-empty directory. // Otherwise the copy/move attempt must overwrite the destination, but @@ -360,72 +350,65 @@ FileSystemFileUtil::PerformCommonCheckAndPreparationForMoveAndCopy( // on all platforms, so we delete the destination directory here. // TODO(kinuko): may be better to change the file_util::{Copy,Move}. if (base::PLATFORM_FILE_OK != - dest_util->Delete(dest_context, dest_file_path, - false /* recursive */)) { - if (!dest_util->IsDirectoryEmpty(dest_context, dest_file_path)) + dest_util->Delete(context, dest_path, false /* recursive */)) { + if (!dest_util->IsDirectoryEmpty(context, dest_path)) return base::PLATFORM_FILE_ERROR_NOT_EMPTY; return base::PLATFORM_FILE_ERROR_FAILED; } - // Reflect changes in usage back to the original context. - if (!same_file_system) - context->set_allowed_bytes_growth(dest_context->allowed_bytes_growth()); } return base::PLATFORM_FILE_OK; } PlatformFileError FileSystemFileUtil::CopyOrMoveDirectory( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path, + const FileSystemPath& src_path, + const FileSystemPath& dest_path, bool copy) { - FileSystemFileUtil* dest_util = context->dest_file_util(); - // All the single-path virtual FSFU methods expect the context information to - // be in the src_* variables, not the dest_* variables, so we have to make a - // new context if we want to call them on the dest_file_path. - scoped_ptr dest_context( - context->CreateInheritedContextForDest()); + FileSystemFileUtil* dest_util = dest_path.file_util(); // Re-check PerformCommonCheckAndPreparationForMoveAndCopy() by DCHECK. - DCHECK(DirectoryExists(context, src_file_path)); - DCHECK(ParentExists(dest_context.get(), dest_util, dest_file_path)); - DCHECK(!dest_util->PathExists(dest_context.get(), dest_file_path)); - if ((context->src_origin_url() == context->dest_origin_url()) && - (context->src_type() == context->dest_type())) - DCHECK(!src_file_path.IsParent(dest_file_path)); - - if (!dest_util->DirectoryExists(dest_context.get(), dest_file_path)) { - PlatformFileError error = dest_util->CreateDirectory(dest_context.get(), - dest_file_path, false, false); + DCHECK(DirectoryExists(context, src_path)); + DCHECK(ParentExists(context, dest_path)); + DCHECK(!dest_util->PathExists(context, dest_path)); + if ((src_path.origin() == dest_path.origin()) && + (src_path.type() == dest_path.type())) + DCHECK(!src_path.IsParent(dest_path)); + + if (!dest_util->DirectoryExists(context, dest_path)) { + PlatformFileError error = dest_util->CreateDirectory( + context, dest_path, false, false); if (error != base::PLATFORM_FILE_OK) return error; - // Reflect changes in usage back to the original context. - context->set_allowed_bytes_growth(dest_context->allowed_bytes_growth()); } scoped_ptr file_enum( - CreateFileEnumerator(context, src_file_path)); + CreateFileEnumerator(context, src_path)); FilePath src_file_path_each; while (!(src_file_path_each = file_enum->Next()).empty()) { - FilePath dest_file_path_each(dest_file_path); - src_file_path.AppendRelativePath(src_file_path_each, &dest_file_path_each); + FilePath dest_file_path_each(dest_path.internal_path()); + src_path.internal_path().AppendRelativePath( + src_file_path_each, &dest_file_path_each); if (file_enum->IsDirectory()) { - PlatformFileError error = dest_util->CreateDirectory(dest_context.get(), - dest_file_path_each, false, false); + PlatformFileError error = dest_util->CreateDirectory( + context, + dest_path.WithInternalPath(dest_file_path_each), + false, false); if (error != base::PLATFORM_FILE_OK) return error; - // Reflect changes in usage back to the original context. - context->set_allowed_bytes_growth(dest_context->allowed_bytes_growth()); } else { PlatformFileError error = CopyOrMoveFileHelper( - context, src_file_path_each, dest_file_path_each, copy); + context, + src_path.WithInternalPath(src_file_path_each), + dest_path.WithInternalPath(dest_file_path_each), + copy); if (error != base::PLATFORM_FILE_OK) return error; } } if (!copy) { - PlatformFileError error = Delete(context, src_file_path, true); + PlatformFileError error = Delete(context, src_path, true); if (error != base::PLATFORM_FILE_OK) return error; } @@ -435,45 +418,46 @@ PlatformFileError FileSystemFileUtil::CopyOrMoveDirectory( PlatformFileError FileSystemFileUtil::CopyOrMoveFileHelper( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path, + const FileSystemPath& src_path, + const FileSystemPath& dest_path, bool copy) { // CopyOrMoveFile here is the virtual overridden member function. - if ((context->src_origin_url() == context->dest_origin_url()) && - (context->src_type() == context->dest_type())) { - DCHECK(context->src_file_util() == context->dest_file_util()); - return CopyOrMoveFile(context, src_file_path, dest_file_path, copy); + if ((src_path.origin() == dest_path.origin()) && + (src_path.type() == dest_path.type())) { + DCHECK(src_path.file_util() == dest_path.file_util()); + return CopyOrMoveFile(context, src_path, dest_path, copy); } + base::PlatformFileInfo file_info; - FilePath platform_file_path; + FilePath underlying_file_path; PlatformFileError error_code; - error_code = - GetFileInfo(context, src_file_path, &file_info, &platform_file_path); + error_code = src_path.file_util()->GetFileInfo( + context, src_path, &file_info, &underlying_file_path); if (error_code != base::PLATFORM_FILE_OK) return error_code; - DCHECK(context->dest_file_util()); - error_code = context->dest_file_util()->CopyInForeignFile( - context, platform_file_path, dest_file_path); + DCHECK(dest_path.file_util()); + error_code = dest_path.file_util()->CopyInForeignFile( + context, src_path.WithInternalPath(underlying_file_path), dest_path); if (copy || error_code != base::PLATFORM_FILE_OK) return error_code; - return DeleteFile(context, src_file_path); + return src_path.file_util()->DeleteFile(context, src_path); } PlatformFileError FileSystemFileUtil::DeleteDirectoryRecursive( FileSystemOperationContext* context, - const FilePath& file_path) { + const FileSystemPath& path) { scoped_ptr file_enum( - CreateFileEnumerator(context, file_path)); + CreateFileEnumerator(context, path)); FilePath file_path_each; - std::stack directories; while (!(file_path_each = file_enum->Next()).empty()) { if (file_enum->IsDirectory()) { directories.push(file_path_each); } else { // DeleteFile here is the virtual overridden member function. - PlatformFileError error = DeleteFile(context, file_path_each); + PlatformFileError error = DeleteFile( + context, path.WithInternalPath(file_path_each)); if (error == base::PLATFORM_FILE_ERROR_NOT_FOUND) return base::PLATFORM_FILE_ERROR_FAILED; else if (error != base::PLATFORM_FILE_OK) @@ -482,14 +466,15 @@ PlatformFileError FileSystemFileUtil::DeleteDirectoryRecursive( } while (!directories.empty()) { - PlatformFileError error = DeleteSingleDirectory(context, directories.top()); + PlatformFileError error = DeleteSingleDirectory( + context, path.WithInternalPath(directories.top())); if (error == base::PLATFORM_FILE_ERROR_NOT_FOUND) return base::PLATFORM_FILE_ERROR_FAILED; else if (error != base::PLATFORM_FILE_OK) return error; directories.pop(); } - return DeleteSingleDirectory(context, file_path); + return DeleteSingleDirectory(context, path); } } // namespace fileapi diff --git a/webkit/fileapi/file_system_file_util.h b/webkit/fileapi/file_system_file_util.h index f96e532..08b2891 100644 --- a/webkit/fileapi/file_system_file_util.h +++ b/webkit/fileapi/file_system_file_util.h @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 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. @@ -8,6 +8,7 @@ #include "base/file_path.h" #include "base/file_util_proxy.h" #include "base/platform_file.h" +#include "webkit/fileapi/file_system_path.h" namespace base { class Time; @@ -58,7 +59,7 @@ class FileSystemFileUtil { virtual ~FileSystemFileUtil(); // Copies or moves a single file. - // Copies a file or a directory from |src_file_path| to |dest_file_path|. + // Copies a file or a directory from |src_path| to |dest_path|. // // Error cases: // If destination's parent doesn't exist. @@ -71,12 +72,14 @@ class FileSystemFileUtil { // target is a directory or not. // - (virtual) CopyOrMoveFile or // - (non-virtual) CopyOrMoveDirectory. + // + // TODO(kinuko,kinaba): Move this cross-FileUtil code out of this interface. PlatformFileError Copy( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path); + const FileSystemPath& src_path, + const FileSystemPath& dest_path); - // Moves a file or a directory from src_file_path to dest_file_path. + // Moves a file or a directory from src_path to dest_path. // // Error cases are similar to Copy method's error cases. // @@ -84,10 +87,12 @@ class FileSystemFileUtil { // target is a directory or not. // - (virtual) CopyOrMoveFile or // - (non-virtual) CopyOrMoveDirectory. + // + // TODO(kinuko,kinaba): Move this cross-FileUtil code out of this interface. PlatformFileError Move( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path); + const FileSystemPath& src_path, + const FileSystemPath& dest_path); // Deletes a file or a directory. // It is an error to delete a non-empty directory with recursive=false. @@ -100,17 +105,17 @@ class FileSystemFileUtil { // - (non-virtual) DeleteDirectoryRecursive which calls two methods above. PlatformFileError Delete( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, bool recursive); // Creates or opens a file with the given flags. It is invalid to pass NULL // for the callback. // If PLATFORM_FILE_CREATE is set in |file_flags| it always tries to create - // a new file at the given |file_path| and calls back with - // PLATFORM_FILE_ERROR_FILE_EXISTS if the |file_path| already exists. + // a new file at the given |path| and calls back with + // PLATFORM_FILE_ERROR_FILE_EXISTS if the |path| already exists. virtual PlatformFileError CreateOrOpen( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, int file_flags, PlatformFile* file_handle, bool* created); @@ -120,9 +125,9 @@ class FileSystemFileUtil { FileSystemOperationContext* context, PlatformFile); - // Ensures that the given |file_path| exist. This creates a empty new file - // at |file_path| if the |file_path| does not exist. - // If a new file han not existed and is created at the |file_path|, + // Ensures that the given |path| exist. This creates a empty new file + // at |path| if the |path| does not exist. + // If a new file han not existed and is created at the |path|, // |created| of the callback argument is set true and |error code| // is set PLATFORM_FILE_OK. // If the file already exists, |created| is set false and |error code| @@ -131,13 +136,13 @@ class FileSystemFileUtil { // reasons, |created| is set false and |error code| indicates the error. virtual PlatformFileError EnsureFileExists( FileSystemOperationContext* context, - const FilePath& file_path, bool* created); + const FileSystemPath& path, bool* created); // Creates directory at given path. It's an error to create // if |exclusive| is true and dir already exists. virtual PlatformFileError CreateDirectory( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, bool exclusive, bool recursive); @@ -145,14 +150,14 @@ class FileSystemFileUtil { // callback. virtual PlatformFileError GetFileInfo( FileSystemOperationContext* context, - const FilePath& file_, + const FileSystemPath& path, base::PlatformFileInfo* file_info, FilePath* platform_path); - // Reads the filenames in |file_path|. + // Reads the filenames in |path|. virtual PlatformFileError ReadDirectory( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, std::vector* entries); // Returns a pointer to a new instance of AbstractFileEnumerator which is @@ -164,21 +169,21 @@ class FileSystemFileUtil { // instance. virtual AbstractFileEnumerator* CreateFileEnumerator( FileSystemOperationContext* context, - const FilePath& root_path); + const FileSystemPath& root_path); - // Maps |virtual_path| given |context| into |local_path| which represents - // physical file location on the host OS. This may not always make sense for - // all subclasses. + // Maps |virtual_path| given |context| into |local_file_path| which represents + // physical file location on the host OS. + // This may not always make sense for all subclasses. virtual PlatformFileError GetLocalFilePath( FileSystemOperationContext* context, - const FilePath& virtual_path, - FilePath* local_path); + const FileSystemPath& file_system_path, + FilePath* local_file_path); // Touches a file. The callback can be NULL. // If the file doesn't exist, this fails with PLATFORM_FILE_ERROR_NOT_FOUND. virtual PlatformFileError Touch( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, const base::Time& last_access_time, const base::Time& last_modified_time); @@ -187,34 +192,34 @@ class FileSystemFileUtil { // The callback can be NULL. virtual PlatformFileError Truncate( FileSystemOperationContext* context, - const FilePath& path, + const FileSystemPath& path, int64 length); virtual bool PathExists( FileSystemOperationContext* context, - const FilePath& file_path); + const FileSystemPath& path); virtual bool DirectoryExists( FileSystemOperationContext* context, - const FilePath& file_path); + const FileSystemPath& path); virtual bool IsDirectoryEmpty( FileSystemOperationContext* context, - const FilePath& file_path); + const FileSystemPath& path); virtual PlatformFileError CopyOrMoveFile( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path, + const FileSystemPath& src_path, + const FileSystemPath& dest_path, bool copy); - // Copies in a single file from a different filesystem. The src_file_path is - // a true local platform path, regardless of which subclass of - // FileSystemFileUtil is being invoked. + // Copies in a single file from a different filesystem. The + // underlying_src_path is a local path which can be handled by the + // underlying filesystem. virtual PlatformFileError CopyInForeignFile( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path); + const FileSystemPath& underlying_src_path, + const FileSystemPath& dest_path); // Deletes a single file. // It assumes the given path points a file. @@ -223,7 +228,7 @@ class FileSystemFileUtil { // non-virtual). virtual PlatformFileError DeleteFile( FileSystemOperationContext* context, - const FilePath& file_path); + const FileSystemPath& path); // Deletes a single empty directory. // It assumes the given path points an empty directory. @@ -232,7 +237,7 @@ class FileSystemFileUtil { // non-virtual). virtual PlatformFileError DeleteSingleDirectory( FileSystemOperationContext* context, - const FilePath& file_path); + const FileSystemPath& path); protected: FileSystemFileUtil(); @@ -243,17 +248,17 @@ class FileSystemFileUtil { // destination). PlatformFileError PerformCommonCheckAndPreparationForMoveAndCopy( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path); + const FileSystemPath& src_path, + const FileSystemPath& dest_path); // Performs recursive copy or move by calling CopyOrMoveFile for individual // files. Operations for recursive traversal are encapsulated in this method. - // It assumes src_file_path and dest_file_path have passed + // It assumes src_path and dest_path have passed // PerformCommonCheckAndPreparationForMoveAndCopy(). PlatformFileError CopyOrMoveDirectory( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path, + const FileSystemPath& src_path, + const FileSystemPath& dest_path, bool copy); // Determines whether a simple same-filesystem move or copy can be done. If @@ -262,8 +267,8 @@ class FileSystemFileUtil { // move] calls DeleteFile on the source file. PlatformFileError CopyOrMoveFileHelper( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path, + const FileSystemPath& src_path, + const FileSystemPath& dest_path, bool copy); // Deletes a directory and all entries under the directory. @@ -275,7 +280,7 @@ class FileSystemFileUtil { // the files are deleted. PlatformFileError DeleteDirectoryRecursive( FileSystemOperationContext* context, - const FilePath& file_path); + const FileSystemPath& path); FileSystemFileUtil* underlying_file_util() const { return underlying_file_util_.get(); diff --git a/webkit/fileapi/file_system_file_util_unittest.cc b/webkit/fileapi/file_system_file_util_unittest.cc index e036405..13071d4 100644 --- a/webkit/fileapi/file_system_file_util_unittest.cc +++ b/webkit/fileapi/file_system_file_util_unittest.cc @@ -55,16 +55,17 @@ class FileSystemFileUtilTest : public testing::Test { false, // unlimited quota NULL, // quota::QuotaManagerProxy file_util.get()); + FileSystemTestOriginHelper dest_helper(dest_origin, dest_type); - dest_helper.SetUp(src_helper.file_system_context(), NULL); + dest_helper.SetUp(src_helper.file_system_context(), file_util.get()); // Set up all the source data. scoped_ptr context; - FilePath test_root(FILE_PATH_LITERAL("root directory")); + FileSystemPath src_root = src_helper.CreatePathFromUTF8("root directory"); for (size_t i = 0; i < test::kRegularTestCaseSize; ++i) { const test::TestCaseRecord& test_case = test::kRegularTestCases[i]; - FilePath path = test_root.Append(test_case.path); + FileSystemPath path = src_root.Append(test_case.path); if (test_case.is_directory) { context.reset(NewContext(&src_helper)); ASSERT_EQ(base::PLATFORM_FILE_OK, @@ -81,29 +82,24 @@ class FileSystemFileUtilTest : public testing::Test { } } + FileSystemPath dest_root = dest_helper.CreatePathFromUTF8("root directory"); + // Do the actual copy or move. - FileSystemContext* file_system_context = dest_helper.file_system_context(); scoped_ptr copy_context( - new FileSystemOperationContext(file_system_context, NULL)); - copy_context->set_src_file_util(file_util); - copy_context->set_dest_file_util(file_util); - copy_context->set_src_origin_url(src_helper.origin()); - copy_context->set_dest_origin_url(dest_helper.origin()); - copy_context->set_src_type(src_helper.type()); - copy_context->set_dest_type(dest_helper.type()); + src_helper.NewOperationContext()); copy_context->set_allowed_bytes_growth(1024 * 1024); // OFSFU path quota. if (copy) ASSERT_EQ(base::PLATFORM_FILE_OK, - file_util->Copy(copy_context.get(), test_root, test_root)); + file_util->Copy(copy_context.get(), src_root, dest_root)); else ASSERT_EQ(base::PLATFORM_FILE_OK, - file_util->Move(copy_context.get(), test_root, test_root)); + file_util->Move(copy_context.get(), src_root, dest_root)); // Validate that the destination paths are correct. for (size_t i = 0; i < test::kRegularTestCaseSize; ++i) { const test::TestCaseRecord& test_case = test::kRegularTestCases[i]; - FilePath path = test_root.Append(test_case.path); + FileSystemPath path = dest_root.Append(test_case.path); base::PlatformFileInfo dest_file_info; FilePath data_path; @@ -127,7 +123,7 @@ class FileSystemFileUtilTest : public testing::Test { // a move]. for (size_t i = 0; i < test::kRegularTestCaseSize; ++i) { const test::TestCaseRecord& test_case = test::kRegularTestCases[i]; - FilePath path = test_root.Append(test_case.path); + FileSystemPath path = src_root.Append(test_case.path); base::PlatformFileInfo src_file_info; FilePath data_path; context.reset(NewContext(&src_helper)); diff --git a/webkit/fileapi/file_system_mount_point_provider.h b/webkit/fileapi/file_system_mount_point_provider.h index ee14ed8..e6b55a9 100644 --- a/webkit/fileapi/file_system_mount_point_provider.h +++ b/webkit/fileapi/file_system_mount_point_provider.h @@ -114,7 +114,7 @@ class ExternalFileSystemMountPointProvider virtual void RemoveMountPoint(const FilePath& mount_point) = 0; // Gets virtual path by known filesystem path. Returns false when filesystem // path is not exposed by this provider. - virtual bool GetVirtualPath(const FilePath& filesystem_path, + virtual bool GetVirtualPath(const FilePath& file_system_path, FilePath* virtual_path) = 0; }; diff --git a/webkit/fileapi/file_system_operation.cc b/webkit/fileapi/file_system_operation.cc index 10a3fc6..3dbe7d8 100644 --- a/webkit/fileapi/file_system_operation.cc +++ b/webkit/fileapi/file_system_operation.cc @@ -32,7 +32,7 @@ class FileSystemOperation::ScopedQuotaUtilHelper { private: FileSystemQuotaUtil* quota_util_; - const GURL& origin_url_; + const GURL origin_url_; FileSystemType type_; DISALLOW_COPY_AND_ASSIGN(ScopedQuotaUtilHelper); }; @@ -41,7 +41,7 @@ FileSystemOperation::ScopedQuotaUtilHelper::ScopedQuotaUtilHelper( FileSystemContext* context, const GURL& origin_url, FileSystemType type) : origin_url_(origin_url), type_(type) { DCHECK(context); - DCHECK(type != kFileSystemTypeUnknown); + DCHECK(type_ != kFileSystemTypeUnknown); quota_util_ = context->GetQuotaUtil(type_); if (quota_util_) { DCHECK(quota_util_->proxy()); @@ -63,26 +63,28 @@ FileSystemOperation::~FileSystemOperation() { base::FileUtilProxy::RelayClose( proxy_, base::Bind(&FileSystemFileUtil::Close, - base::Unretained(c->src_file_util()), + base::Unretained(src_path_.file_util()), base::Owned(c)), file_writer_delegate_->file(), base::FileUtilProxy::StatusCallback()); } } -void FileSystemOperation::CreateFile(const GURL& path, +void FileSystemOperation::CreateFile(const GURL& path_url, bool exclusive, const StatusCallback& callback) { DCHECK(SetPendingOperationType(kOperationCreateFile)); - base::PlatformFileError result = SetupSrcContextForWrite(path, true); + base::PlatformFileError result = SetUpFileSystemPath( + path_url, &src_path_, PATH_FOR_CREATE); if (result != base::PLATFORM_FILE_OK) { callback.Run(result); delete this; return; } + GetUsageAndQuotaThenCallback( - operation_context_.src_origin_url(), + src_path_.origin(), src_path_.type(), base::Bind(&FileSystemOperation::DelayedCreateFileForQuota, base::Unretained(this), callback, exclusive)); } @@ -95,34 +97,36 @@ void FileSystemOperation::DelayedCreateFileForQuota( quota_util_helper_.reset(new ScopedQuotaUtilHelper( file_system_context(), - operation_context_.src_origin_url(), - operation_context_.src_type())); + src_path_.origin(), + src_path_.type())); FileSystemFileUtilProxy::RelayEnsureFileExists( proxy_, base::Bind(&FileSystemFileUtil::EnsureFileExists, - base::Unretained(operation_context_.src_file_util()), - &operation_context_, src_virtual_path_), + base::Unretained(src_path_.file_util()), + &operation_context_, + src_path_), base::Bind( exclusive ? &FileSystemOperation::DidEnsureFileExistsExclusive : &FileSystemOperation::DidEnsureFileExistsNonExclusive, base::Owned(this), callback)); } -void FileSystemOperation::CreateDirectory(const GURL& path, +void FileSystemOperation::CreateDirectory(const GURL& path_url, bool exclusive, bool recursive, const StatusCallback& callback) { DCHECK(SetPendingOperationType(kOperationCreateDirectory)); - base::PlatformFileError result = SetupSrcContextForWrite(path, true); + base::PlatformFileError result = SetUpFileSystemPath( + path_url, &src_path_, PATH_FOR_CREATE); if (result != base::PLATFORM_FILE_OK) { callback.Run(result); delete this; return; } GetUsageAndQuotaThenCallback( - operation_context_.src_origin_url(), + src_path_.origin(), src_path_.type(), base::Bind(&FileSystemOperation::DelayedCreateDirectoryForQuota, base::Unretained(this), callback, exclusive, recursive)); } @@ -135,27 +139,28 @@ void FileSystemOperation::DelayedCreateDirectoryForQuota( quota_util_helper_.reset(new ScopedQuotaUtilHelper( file_system_context(), - operation_context_.src_origin_url(), - operation_context_.src_type())); + src_path_.origin(), + src_path_.type())); base::FileUtilProxy::RelayFileTask( proxy_, FROM_HERE, base::Bind(&FileSystemFileUtil::CreateDirectory, - base::Unretained(operation_context_.src_file_util()), + base::Unretained(src_path_.file_util()), &operation_context_, - src_virtual_path_, exclusive, recursive), + src_path_, exclusive, recursive), base::Bind(&FileSystemOperation::DidFinishFileOperation, base::Owned(this), callback)); } -void FileSystemOperation::Copy(const GURL& src_path, - const GURL& dest_path, +void FileSystemOperation::Copy(const GURL& src_path_url, + const GURL& dest_path_url, const StatusCallback& callback) { DCHECK(SetPendingOperationType(kOperationCopy)); - base::PlatformFileError result = SetupSrcContextForRead(src_path); + base::PlatformFileError result = SetUpFileSystemPath( + src_path_url, &src_path_, PATH_FOR_READ); if (result == base::PLATFORM_FILE_OK) - result = SetupDestContextForWrite(dest_path, true); + result = SetUpFileSystemPath(dest_path_url, &dest_path_, PATH_FOR_CREATE); if (result != base::PLATFORM_FILE_OK) { callback.Run(result); delete this; @@ -163,7 +168,7 @@ void FileSystemOperation::Copy(const GURL& src_path, } GetUsageAndQuotaThenCallback( - operation_context_.dest_origin_url(), + dest_path_.origin(), dest_path_.type(), base::Bind(&FileSystemOperation::DelayedCopyForQuota, base::Unretained(this), callback)); } @@ -175,27 +180,29 @@ void FileSystemOperation::DelayedCopyForQuota(const StatusCallback& callback, quota_util_helper_.reset(new ScopedQuotaUtilHelper( file_system_context(), - operation_context_.dest_origin_url(), - operation_context_.dest_type())); + dest_path_.origin(), + dest_path_.type())); base::FileUtilProxy::RelayFileTask( proxy_, FROM_HERE, base::Bind(&FileSystemFileUtil::Copy, - base::Unretained(operation_context_.src_file_util()), + base::Unretained(dest_path_.file_util()), &operation_context_, - src_virtual_path_, dest_virtual_path_), + src_path_, + dest_path_), base::Bind(&FileSystemOperation::DidFinishFileOperation, base::Owned(this), callback)); } -void FileSystemOperation::Move(const GURL& src_path, - const GURL& dest_path, +void FileSystemOperation::Move(const GURL& src_path_url, + const GURL& dest_path_url, const StatusCallback& callback) { DCHECK(SetPendingOperationType(kOperationMove)); - base::PlatformFileError result = SetupSrcContextForWrite(src_path, false); + base::PlatformFileError result = SetUpFileSystemPath( + src_path_url, &src_path_, PATH_FOR_WRITE); if (result == base::PLATFORM_FILE_OK) - result = SetupDestContextForWrite(dest_path, true); + result = SetUpFileSystemPath(dest_path_url, &dest_path_, PATH_FOR_CREATE); if (result != base::PLATFORM_FILE_OK) { callback.Run(result); delete this; @@ -203,7 +210,7 @@ void FileSystemOperation::Move(const GURL& src_path, } GetUsageAndQuotaThenCallback( - operation_context_.dest_origin_url(), + dest_path_.origin(), dest_path_.type(), base::Bind(&FileSystemOperation::DelayedMoveForQuota, base::Unretained(this), callback)); } @@ -215,24 +222,26 @@ void FileSystemOperation::DelayedMoveForQuota(const StatusCallback& callback, quota_util_helper_.reset(new ScopedQuotaUtilHelper( file_system_context(), - operation_context_.dest_origin_url(), - operation_context_.dest_type())); + dest_path_.origin(), + dest_path_.type())); base::FileUtilProxy::RelayFileTask( proxy_, FROM_HERE, base::Bind(&FileSystemFileUtil::Move, - base::Unretained(operation_context_.src_file_util()), + base::Unretained(dest_path_.file_util()), &operation_context_, - src_virtual_path_, dest_virtual_path_), + src_path_, + dest_path_), base::Bind(&FileSystemOperation::DidFinishFileOperation, base::Owned(this), callback)); } -void FileSystemOperation::DirectoryExists(const GURL& path, +void FileSystemOperation::DirectoryExists(const GURL& path_url, const StatusCallback& callback) { DCHECK(SetPendingOperationType(kOperationDirectoryExists)); - base::PlatformFileError result = SetupSrcContextForRead(path); + base::PlatformFileError result = SetUpFileSystemPath( + path_url, &src_path_, PATH_FOR_READ); if (result != base::PLATFORM_FILE_OK) { callback.Run(result); delete this; @@ -242,17 +251,19 @@ void FileSystemOperation::DirectoryExists(const GURL& path, FileSystemFileUtilProxy::RelayGetFileInfo( proxy_, base::Bind(&FileSystemFileUtil::GetFileInfo, - base::Unretained(operation_context_.src_file_util()), - &operation_context_, src_virtual_path_), + base::Unretained(src_path_.file_util()), + &operation_context_, + src_path_), base::Bind(&FileSystemOperation::DidDirectoryExists, base::Owned(this), callback)); } -void FileSystemOperation::FileExists(const GURL& path, +void FileSystemOperation::FileExists(const GURL& path_url, const StatusCallback& callback) { DCHECK(SetPendingOperationType(kOperationFileExists)); - base::PlatformFileError result = SetupSrcContextForRead(path); + base::PlatformFileError result = SetUpFileSystemPath( + path_url, &src_path_, PATH_FOR_READ); if (result != base::PLATFORM_FILE_OK) { callback.Run(result); delete this; @@ -262,17 +273,18 @@ void FileSystemOperation::FileExists(const GURL& path, FileSystemFileUtilProxy::RelayGetFileInfo( proxy_, base::Bind(&FileSystemFileUtil::GetFileInfo, - base::Unretained(operation_context_.src_file_util()), - &operation_context_, src_virtual_path_), + base::Unretained(src_path_.file_util()), + &operation_context_, src_path_), base::Bind(&FileSystemOperation::DidFileExists, base::Owned(this), callback)); } -void FileSystemOperation::GetMetadata(const GURL& path, +void FileSystemOperation::GetMetadata(const GURL& path_url, const GetMetadataCallback& callback) { DCHECK(SetPendingOperationType(kOperationGetMetadata)); - base::PlatformFileError result = SetupSrcContextForRead(path); + base::PlatformFileError result = SetUpFileSystemPath( + path_url, &src_path_, PATH_FOR_READ); if (result != base::PLATFORM_FILE_OK) { callback.Run(result, base::PlatformFileInfo(), FilePath()); delete this; @@ -282,17 +294,18 @@ void FileSystemOperation::GetMetadata(const GURL& path, FileSystemFileUtilProxy::RelayGetFileInfo( proxy_, base::Bind(&FileSystemFileUtil::GetFileInfo, - base::Unretained(operation_context_.src_file_util()), - &operation_context_, src_virtual_path_), + base::Unretained(src_path_.file_util()), + &operation_context_, src_path_), base::Bind(&FileSystemOperation::DidGetMetadata, base::Owned(this), callback)); } -void FileSystemOperation::ReadDirectory(const GURL& path, +void FileSystemOperation::ReadDirectory(const GURL& path_url, const ReadDirectoryCallback& callback) { DCHECK(SetPendingOperationType(kOperationReadDirectory)); - base::PlatformFileError result = SetupSrcContextForRead(path); + base::PlatformFileError result = SetUpFileSystemPath( + path_url, &src_path_, PATH_FOR_READ); if (result != base::PLATFORM_FILE_OK) { callback.Run(result, std::vector(), false); delete this; @@ -302,17 +315,18 @@ void FileSystemOperation::ReadDirectory(const GURL& path, FileSystemFileUtilProxy::RelayReadDirectory( proxy_, base::Bind(&FileSystemFileUtil::ReadDirectory, - base::Unretained(operation_context_.src_file_util()), - &operation_context_, src_virtual_path_), + base::Unretained(src_path_.file_util()), + &operation_context_, src_path_), base::Bind(&FileSystemOperation::DidReadDirectory, base::Owned(this), callback)); } -void FileSystemOperation::Remove(const GURL& path, bool recursive, +void FileSystemOperation::Remove(const GURL& path_url, bool recursive, const StatusCallback& callback) { DCHECK(SetPendingOperationType(kOperationRemove)); - base::PlatformFileError result = SetupSrcContextForWrite(path, false); + base::PlatformFileError result = SetUpFileSystemPath( + path_url, &src_path_, PATH_FOR_WRITE); if (result != base::PLATFORM_FILE_OK) { callback.Run(result); delete this; @@ -322,35 +336,38 @@ void FileSystemOperation::Remove(const GURL& path, bool recursive, base::FileUtilProxy::RelayFileTask( proxy_, FROM_HERE, base::Bind(&FileSystemFileUtil::Delete, - base::Unretained(operation_context_.src_file_util()), - &operation_context_, src_virtual_path_, recursive), + base::Unretained(src_path_.file_util()), + &operation_context_, src_path_, + recursive), base::Bind(&FileSystemOperation::DidFinishFileOperation, base::Owned(this), callback)); } void FileSystemOperation::Write( const net::URLRequestContext* url_request_context, - const GURL& path, + const GURL& path_url, const GURL& blob_url, int64 offset, const WriteCallback& callback) { DCHECK(SetPendingOperationType(kOperationWrite)); - base::PlatformFileError result = SetupSrcContextForWrite(path, true); + base::PlatformFileError result = SetUpFileSystemPath( + path_url, &src_path_, PATH_FOR_WRITE); if (result != base::PLATFORM_FILE_OK) { callback.Run(result, 0, false); delete this; return; } DCHECK(blob_url.is_valid()); - file_writer_delegate_.reset(new FileWriterDelegate(this, offset, proxy_)); + file_writer_delegate_.reset(new FileWriterDelegate( + this, src_path_, offset, proxy_)); set_write_callback(callback); blob_request_.reset( new net::URLRequest(blob_url, file_writer_delegate_.get())); blob_request_->set_context(url_request_context); GetUsageAndQuotaThenCallback( - operation_context_.src_origin_url(), + src_path_.origin(), src_path_.type(), base::Bind(&FileSystemOperation::DelayedWriteForQuota, base::Unretained(this))); } @@ -361,8 +378,8 @@ void FileSystemOperation::DelayedWriteForQuota(quota::QuotaStatusCode status, quota_util_helper_.reset(new ScopedQuotaUtilHelper( file_system_context(), - operation_context_.src_origin_url(), - operation_context_.src_type())); + src_path_.origin(), + src_path_.type())); int file_flags = base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE | @@ -371,27 +388,30 @@ void FileSystemOperation::DelayedWriteForQuota(quota::QuotaStatusCode status, base::FileUtilProxy::RelayCreateOrOpen( proxy_, base::Bind(&FileSystemFileUtil::CreateOrOpen, - base::Unretained(operation_context_.src_file_util()), - &operation_context_, src_virtual_path_, file_flags), + base::Unretained(src_path_.file_util()), + &operation_context_, + src_path_, + file_flags), base::Bind(&FileSystemFileUtil::Close, - base::Unretained(operation_context_.src_file_util()), + base::Unretained(src_path_.file_util()), &operation_context_), base::Bind(&FileSystemOperation::OnFileOpenedForWrite, base::Unretained(this))); } -void FileSystemOperation::Truncate(const GURL& path, int64 length, +void FileSystemOperation::Truncate(const GURL& path_url, int64 length, const StatusCallback& callback) { DCHECK(SetPendingOperationType(kOperationTruncate)); - base::PlatformFileError result = SetupSrcContextForWrite(path, false); + base::PlatformFileError result = SetUpFileSystemPath( + path_url, &src_path_, PATH_FOR_WRITE); if (result != base::PLATFORM_FILE_OK) { callback.Run(result); delete this; return; } GetUsageAndQuotaThenCallback( - operation_context_.src_origin_url(), + src_path_.origin(), src_path_.type(), base::Bind(&FileSystemOperation::DelayedTruncateForQuota, base::Unretained(this), callback, length)); } @@ -403,25 +423,26 @@ void FileSystemOperation::DelayedTruncateForQuota( quota_util_helper_.reset(new ScopedQuotaUtilHelper( file_system_context(), - operation_context_.src_origin_url(), - operation_context_.src_type())); + src_path_.origin(), + src_path_.type())); base::FileUtilProxy::RelayFileTask( proxy_, FROM_HERE, base::Bind(&FileSystemFileUtil::Truncate, - base::Unretained(operation_context_.src_file_util()), - &operation_context_, src_virtual_path_, length), + base::Unretained(src_path_.file_util()), + &operation_context_, src_path_, length), base::Bind(&FileSystemOperation::DidFinishFileOperation, base::Owned(this), callback)); } -void FileSystemOperation::TouchFile(const GURL& path, +void FileSystemOperation::TouchFile(const GURL& path_url, const base::Time& last_access_time, const base::Time& last_modified_time, const StatusCallback& callback) { DCHECK(SetPendingOperationType(kOperationTouchFile)); - base::PlatformFileError result = SetupSrcContextForWrite(path, true); + base::PlatformFileError result = SetUpFileSystemPath( + path_url, &src_path_, PATH_FOR_WRITE); if (result != base::PLATFORM_FILE_OK) { callback.Run(result); delete this; @@ -431,18 +452,20 @@ void FileSystemOperation::TouchFile(const GURL& path, base::FileUtilProxy::RelayFileTask( proxy_, FROM_HERE, base::Bind(&FileSystemFileUtil::Touch, - base::Unretained(operation_context_.src_file_util()), + base::Unretained(src_path_.file_util()), &operation_context_, - src_virtual_path_, last_access_time, last_modified_time), + src_path_, + last_access_time, last_modified_time), base::Bind(&FileSystemOperation::DidTouchFile, base::Owned(this), callback)); } -void FileSystemOperation::OpenFile(const GURL& path, +void FileSystemOperation::OpenFile(const GURL& path_url, int file_flags, base::ProcessHandle peer_handle, const OpenFileCallback& callback) { DCHECK(SetPendingOperationType(kOperationOpenFile)); + scoped_ptr deleter(this); peer_handle_ = peer_handle; @@ -451,7 +474,6 @@ void FileSystemOperation::OpenFile(const GURL& path, base::PLATFORM_FILE_HIDDEN))) { callback.Run(base::PLATFORM_FILE_ERROR_FAILED, base::PlatformFile(), base::ProcessHandle()); - delete this; return; } if (file_flags & @@ -460,24 +482,24 @@ void FileSystemOperation::OpenFile(const GURL& path, base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_EXCLUSIVE_WRITE | base::PLATFORM_FILE_DELETE_ON_CLOSE | base::PLATFORM_FILE_WRITE_ATTRIBUTES)) { - base::PlatformFileError result = SetupSrcContextForWrite(path, true); + base::PlatformFileError result = SetUpFileSystemPath( + path_url, &src_path_, PATH_FOR_CREATE); if (result != base::PLATFORM_FILE_OK) { callback.Run(result, base::PlatformFile(), base::ProcessHandle()); - delete this; return; } } else { - base::PlatformFileError result = SetupSrcContextForRead(path); + base::PlatformFileError result = SetUpFileSystemPath( + path_url, &src_path_, PATH_FOR_READ); if (result != base::PLATFORM_FILE_OK) { callback.Run(result, base::PlatformFile(), base::ProcessHandle()); - delete this; return; } } GetUsageAndQuotaThenCallback( - operation_context_.src_origin_url(), + src_path_.origin(), src_path_.type(), base::Bind(&FileSystemOperation::DelayedOpenFileForQuota, - base::Unretained(this), callback, file_flags)); + base::Unretained(deleter.release()), callback, file_flags)); } void FileSystemOperation::DelayedOpenFileForQuota( @@ -487,17 +509,17 @@ void FileSystemOperation::DelayedOpenFileForQuota( quota_util_helper_.reset(new ScopedQuotaUtilHelper( file_system_context(), - operation_context_.src_origin_url(), - operation_context_.src_type())); + src_path_.origin(), + src_path_.type())); base::FileUtilProxy::RelayCreateOrOpen( proxy_, base::Bind(&FileSystemFileUtil::CreateOrOpen, - base::Unretained(operation_context_.src_file_util()), + base::Unretained(src_path_.file_util()), &operation_context_, - src_virtual_path_, file_flags), + src_path_, file_flags), base::Bind(&FileSystemFileUtil::Close, - base::Unretained(operation_context_.src_file_util()), + base::Unretained(src_path_.file_util()), &operation_context_), base::Bind(&FileSystemOperation::DidOpenFile, base::Owned(this), callback)); @@ -540,18 +562,19 @@ FileSystemOperation* FileSystemOperation::AsFileSystemOperation() { return this; } -void FileSystemOperation::SyncGetPlatformPath(const GURL& path, +void FileSystemOperation::SyncGetPlatformPath(const GURL& path_url, FilePath* platform_path) { DCHECK(SetPendingOperationType(kOperationGetLocalPath)); - base::PlatformFileError result = SetupSrcContextForRead(path); + base::PlatformFileError result = SetUpFileSystemPath( + path_url, &src_path_, PATH_FOR_READ); if (result != base::PLATFORM_FILE_OK) { delete this; return; } - operation_context_.src_file_util()->GetLocalFilePath( - &operation_context_, src_virtual_path_, platform_path); + src_path_.file_util()->GetLocalFilePath( + &operation_context_, src_path_, platform_path); delete this; } @@ -560,19 +583,18 @@ FileSystemOperation::FileSystemOperation( scoped_refptr proxy, FileSystemContext* file_system_context) : proxy_(proxy), - operation_context_(file_system_context, NULL), + operation_context_(file_system_context), peer_handle_(base::kNullProcessHandle), pending_operation_(kOperationNone) { } void FileSystemOperation::GetUsageAndQuotaThenCallback( - const GURL& origin_url, + const GURL& origin, FileSystemType type, const quota::QuotaManager::GetUsageAndQuotaCallback& callback) { quota::QuotaManagerProxy* quota_manager_proxy = file_system_context()->quota_manager_proxy(); if (!quota_manager_proxy || - !file_system_context()->GetQuotaUtil( - operation_context_.src_type())) { + !file_system_context()->GetQuotaUtil(type)) { // If we don't have the quota manager or the requested filesystem type // does not support quota, we should be able to let it go. callback.Run(quota::kQuotaStatusOk, 0, kint64max); @@ -581,9 +603,8 @@ void FileSystemOperation::GetUsageAndQuotaThenCallback( DCHECK(quota_manager_proxy); DCHECK(quota_manager_proxy->quota_manager()); quota_manager_proxy->quota_manager()->GetUsageAndQuota( - operation_context_.src_origin_url(), - FileSystemTypeToQuotaStorageType( - operation_context_.src_type()), + origin, + FileSystemTypeToQuotaStorageType(type), callback); } @@ -696,114 +717,65 @@ void FileSystemOperation::OnFileOpenedForWrite( file_writer_delegate_->Start(file.ReleaseValue(), blob_request_.get()); } -base::PlatformFileError FileSystemOperation::VerifyFileSystemPathForRead( - const GURL& path, GURL* origin_url, FileSystemType* type, - FilePath* virtual_path, FileSystemFileUtil** file_util) { - base::PlatformFileError rv = - VerifyFileSystemPath(path, origin_url, type, virtual_path, file_util); - if (rv != base::PLATFORM_FILE_OK) - return rv; - - // We notify this read access whether the read access succeeds or not. - // This must be ok since this is used to let the QM's eviction logic know - // someone is interested in reading the origin data and therefore to indicate - // that evicting this origin may not be a good idea. - FileSystemQuotaUtil* quota_util = file_system_context()->GetQuotaUtil(*type); - if (quota_util) { - quota_util->NotifyOriginWasAccessedOnIOThread( - file_system_context()->quota_manager_proxy(), - *origin_url, - *type); - } - - return base::PLATFORM_FILE_OK; -} - -base::PlatformFileError FileSystemOperation::VerifyFileSystemPathForWrite( - const GURL& path, bool create, GURL* origin_url, FileSystemType* type, - FilePath* virtual_path, FileSystemFileUtil** file_util) { - base::PlatformFileError rv = - VerifyFileSystemPath(path, origin_url, type, virtual_path, file_util); - if (rv != base::PLATFORM_FILE_OK) - return rv; +base::PlatformFileError FileSystemOperation::SetUpFileSystemPath( + const GURL& path_url, + FileSystemPath* file_system_path, + SetUpPathMode mode) { + DCHECK(file_system_path); + GURL origin_url; + FileSystemType type; + FilePath cracked_path; + if (!CrackFileSystemURL(path_url, &origin_url, &type, &cracked_path)) + return base::PLATFORM_FILE_ERROR_INVALID_URL; - // Any write access is disallowed on the root path. - if (virtual_path->value().length() == 0 || - virtual_path->DirName().value() == virtual_path->value()) { + if (!file_system_context()->GetMountPointProvider(type)->IsAccessAllowed( + origin_url, type, cracked_path)) return base::PLATFORM_FILE_ERROR_SECURITY; - } - if (create && - file_system_context()->GetMountPointProvider(*type)->IsRestrictedFileName( - virtual_path->BaseName())) { + + FileSystemFileUtil* file_util = file_system_context()->GetFileUtil(type); + if (!file_util) return base::PLATFORM_FILE_ERROR_SECURITY; - } - return base::PLATFORM_FILE_OK; -} + file_system_path->set_origin(origin_url); + file_system_path->set_type(type); + file_system_path->set_internal_path(cracked_path); + if (!file_system_path->file_util()) + file_system_path->set_file_util(file_util); + + if (mode == PATH_FOR_READ) { + // We notify this read access whether the read access succeeds or not. + // This must be ok since this is used to let the QM's eviction logic know + // someone is interested in reading the origin data and therefore to + // indicate that evicting this origin may not be a good idea. + FileSystemQuotaUtil* quota_util = file_system_context()->GetQuotaUtil(type); + if (quota_util) { + quota_util->NotifyOriginWasAccessedOnIOThread( + file_system_context()->quota_manager_proxy(), + file_system_path->origin(), + file_system_path->type()); + } + return base::PLATFORM_FILE_OK; + } -base::PlatformFileError FileSystemOperation::VerifyFileSystemPath( - const GURL& path, GURL* origin_url, FileSystemType* type, - FilePath* virtual_path, FileSystemFileUtil** file_util) { - DCHECK(file_system_context()); + DCHECK(mode == PATH_FOR_WRITE || mode == PATH_FOR_CREATE); - if (!CrackFileSystemURL(path, origin_url, type, virtual_path)) { - return base::PLATFORM_FILE_ERROR_INVALID_URL; - } - if (!file_system_context()->GetMountPointProvider(*type)->IsAccessAllowed( - *origin_url, *type, *virtual_path)) { + // Any write access is disallowed on the root path. + if (cracked_path.value().length() == 0 || + cracked_path.DirName().value() == cracked_path.value()) return base::PLATFORM_FILE_ERROR_SECURITY; + + if (mode == PATH_FOR_CREATE) { + FileSystemMountPointProvider* provider = file_system_context()-> + GetMountPointProvider(type); + + // Check if the cracked file name looks good to create. + if (provider->IsRestrictedFileName(cracked_path.BaseName())) + return base::PLATFORM_FILE_ERROR_SECURITY; } - DCHECK(file_util); - *file_util = file_system_context()->GetFileUtil(*type); - DCHECK(*file_util); return base::PLATFORM_FILE_OK; } -base::PlatformFileError FileSystemOperation::SetupSrcContextForRead( - const GURL& path) { - GURL origin_url; - FileSystemType type; - FileSystemFileUtil* file_util; - base::PlatformFileError result = VerifyFileSystemPathForRead( - path, &origin_url, &type, &src_virtual_path_, &file_util); - operation_context_.set_src_origin_url(origin_url); - operation_context_.set_src_type(type); - if (!operation_context_.src_file_util()) - operation_context_.set_src_file_util(file_util); - return result; -} - -base::PlatformFileError FileSystemOperation::SetupSrcContextForWrite( - const GURL& path, - bool create) { - GURL origin_url; - FileSystemType type; - FileSystemFileUtil* file_util = NULL; - base::PlatformFileError result = VerifyFileSystemPathForWrite( - path, create, &origin_url, &type, &src_virtual_path_, &file_util); - operation_context_.set_src_origin_url(origin_url); - operation_context_.set_src_type(type); - if (!operation_context_.src_file_util()) - operation_context_.set_src_file_util(file_util); - return result; -} - -base::PlatformFileError FileSystemOperation::SetupDestContextForWrite( - const GURL& path, - bool create) { - GURL origin_url; - FileSystemType type; - FileSystemFileUtil* file_util = NULL; - base::PlatformFileError result = VerifyFileSystemPathForWrite( - path, create, &origin_url, &type, &dest_virtual_path_, &file_util); - operation_context_.set_dest_origin_url(origin_url); - operation_context_.set_dest_type(type); - if (!operation_context_.dest_file_util()) - operation_context_.set_dest_file_util(file_util); - return result; -} - bool FileSystemOperation::SetPendingOperationType(OperationType type) { if (pending_operation_ != kOperationNone) return false; diff --git a/webkit/fileapi/file_system_operation.h b/webkit/fileapi/file_system_operation.h index 5c05c97..b70d3dfa 100644 --- a/webkit/fileapi/file_system_operation.h +++ b/webkit/fileapi/file_system_operation.h @@ -49,49 +49,49 @@ class FileSystemOperation : public FileSystemOperationInterface { virtual ~FileSystemOperation(); // FileSystemOperation overrides. - virtual void CreateFile(const GURL& path, + virtual void CreateFile(const GURL& path_url, bool exclusive, const StatusCallback& callback) OVERRIDE; - virtual void CreateDirectory(const GURL& path, + virtual void CreateDirectory(const GURL& path_url, bool exclusive, bool recursive, const StatusCallback& callback) OVERRIDE; - virtual void Copy(const GURL& src_path, - const GURL& dest_path, + virtual void Copy(const GURL& src_path_url, + const GURL& dest_path_url, const StatusCallback& callback) OVERRIDE; - virtual void Move(const GURL& src_path, - const GURL& dest_path, + virtual void Move(const GURL& src_path_url, + const GURL& dest_path_url, const StatusCallback& callback) OVERRIDE; - virtual void DirectoryExists(const GURL& path, + virtual void DirectoryExists(const GURL& path_url, const StatusCallback& callback) OVERRIDE; - virtual void FileExists(const GURL& path, + virtual void FileExists(const GURL& path_url, const StatusCallback& callback) OVERRIDE; - virtual void GetMetadata(const GURL& path, + virtual void GetMetadata(const GURL& path_url, const GetMetadataCallback& callback) OVERRIDE; - virtual void ReadDirectory(const GURL& path, + virtual void ReadDirectory(const GURL& path_url, const ReadDirectoryCallback& callback) OVERRIDE; - virtual void Remove(const GURL& path, bool recursive, + virtual void Remove(const GURL& path_url, bool recursive, const StatusCallback& callback) OVERRIDE; virtual void Write(const net::URLRequestContext* url_request_context, - const GURL& path, + const GURL& path_url, const GURL& blob_url, int64 offset, const WriteCallback& callback) OVERRIDE; - virtual void Truncate(const GURL& path, int64 length, + virtual void Truncate(const GURL& path_url, int64 length, const StatusCallback& callback) OVERRIDE; - virtual void TouchFile(const GURL& path, + virtual void TouchFile(const GURL& path_url, const base::Time& last_access_time, const base::Time& last_modified_time, const StatusCallback& callback) OVERRIDE; - virtual void OpenFile(const GURL& path, + virtual void OpenFile(const GURL& path_url, int file_flags, base::ProcessHandle peer_handle, const OpenFileCallback& callback) OVERRIDE; virtual void Cancel(const StatusCallback& cancel_callback) OVERRIDE; virtual FileSystemOperation* AsFileSystemOperation() OVERRIDE; - // Synchronously gets the platform path for the given |path|. - void SyncGetPlatformPath(const GURL& path, FilePath* platform_path); + // Synchronously gets the platform path for the given |path_url|. + void SyncGetPlatformPath(const GURL& path_url, FilePath* platform_path); protected: class ScopedQuotaUtilHelper; @@ -123,12 +123,13 @@ class FileSystemOperation : public FileSystemOperationInterface { // file_util on their own should call this before performing the actual // operation. If it is given it will not be overwritten by the class. void set_override_file_util(FileSystemFileUtil* file_util) { - operation_context_.set_src_file_util(file_util); - operation_context_.set_dest_file_util(file_util); + src_path_.set_file_util(file_util); + dest_path_.set_file_util(file_util); } void GetUsageAndQuotaThenCallback( - const GURL& origin_url, + const GURL& origin, + FileSystemType type, const quota::QuotaManager::GetUsageAndQuotaCallback& callback); void DelayedCreateFileForQuota(const StatusCallback& callback, @@ -202,60 +203,18 @@ class FileSystemOperation : public FileSystemOperationInterface { base::PassPlatformFile file, bool created); - // Checks the validity of a given |path| for reading, cracks the path into - // root URL and virtual path components, and returns the correct - // FileSystemFileUtil subclass for this type. - // Returns true if the given |path| is a valid FileSystem path. - // Otherwise it calls dispatcher's DidFail method with - // PLATFORM_FILE_ERROR_SECURITY and returns false. - // (Note: this doesn't delete this when it calls DidFail and returns false; - // it's the caller's responsibility.) - base::PlatformFileError VerifyFileSystemPathForRead( - const GURL& path, - GURL* root_url, - FileSystemType* type, - FilePath* virtual_path, - FileSystemFileUtil** file_util); - - // Checks the validity of a given |path| for writing, cracks the path into - // root URL and virtual path components, and returns the correct - // FileSystemFileUtil subclass for this type. - // Returns true if the given |path| is a valid FileSystem path, and - // its origin embedded in the path has the right to write. - // Otherwise it fires dispatcher's DidFail method with - // PLATFORM_FILE_ERROR_SECURITY if the path is not valid for writing, - // or with PLATFORM_FILE_ERROR_NO_SPACE if the origin is not allowed to - // write to the storage. - // In either case it returns false after firing DidFail. - // If |create| flag is true this also checks if the |path| contains - // any restricted names and chars. If it does, the call fires dispatcher's - // DidFail with PLATFORM_FILE_ERROR_SECURITY and returns false. - // (Note: this doesn't delete this when it calls DidFail and returns false; - // it's the caller's responsibility.) - base::PlatformFileError VerifyFileSystemPathForWrite( - const GURL& path, - bool create, - GURL* root_url, - FileSystemType* type, - FilePath* virtual_path, - FileSystemFileUtil** file_util); - - // Common internal routine for VerifyFileSystemPathFor{Read,Write}. - base::PlatformFileError VerifyFileSystemPath(const GURL& path, - GURL* root_url, - FileSystemType* type, - FilePath* virtual_path, - FileSystemFileUtil** file_util); - - // Setup*Context*() functions will call the appropriate VerifyFileSystem - // function and store the results to operation_context_ and - // *_virtual_path_. - // Return the result of VerifyFileSystem*(). - base::PlatformFileError SetupSrcContextForRead(const GURL& path); - base::PlatformFileError SetupSrcContextForWrite(const GURL& path, - bool create); - base::PlatformFileError SetupDestContextForWrite(const GURL& path, - bool create); + enum SetUpPathMode { + PATH_FOR_READ, + PATH_FOR_WRITE, + PATH_FOR_CREATE, + }; + + // Checks the validity of a given |path_url| and and sets up the + // |file_system_path| for |mode|. + base::PlatformFileError SetUpFileSystemPath( + const GURL& path_url, + FileSystemPath* file_system_path, + SetUpPathMode mode); // Used only for internal assertions. // Returns false if there's another inflight pending operation. @@ -265,6 +224,8 @@ class FileSystemOperation : public FileSystemOperationInterface { scoped_refptr proxy_; FileSystemOperationContext operation_context_; + FileSystemPath src_path_; + FileSystemPath dest_path_; scoped_ptr quota_util_helper_; @@ -287,12 +248,6 @@ class FileSystemOperation : public FileSystemOperationInterface { // requesting process. base::ProcessHandle peer_handle_; - // Used to keep a virtual path around while we check for quota. - // If an operation needs only one path, use src_virtual_path_, even if it's a - // write. - FilePath src_virtual_path_; - FilePath dest_virtual_path_; - // A flag to make sure we call operation only once per instance. OperationType pending_operation_; diff --git a/webkit/fileapi/file_system_operation_context.cc b/webkit/fileapi/file_system_operation_context.cc index 5f0abf0..0f33024 100644 --- a/webkit/fileapi/file_system_operation_context.cc +++ b/webkit/fileapi/file_system_operation_context.cc @@ -1,36 +1,18 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 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_context.h" #include "webkit/fileapi/file_system_context.h" -#include "webkit/fileapi/file_system_util.h" namespace fileapi { FileSystemOperationContext::FileSystemOperationContext( - FileSystemContext* context, - FileSystemFileUtil* file_util) + FileSystemContext* context) : file_system_context_(context), - src_file_util_(file_util), - dest_file_util_(file_util), - src_type_(kFileSystemTypeUnknown), - dest_type_(kFileSystemTypeUnknown), - allowed_bytes_growth_(0) { -} + allowed_bytes_growth_(0) {} -FileSystemOperationContext::~FileSystemOperationContext() { -} - -FileSystemOperationContext* -FileSystemOperationContext::CreateInheritedContextForDest() const { - FileSystemOperationContext* context = new FileSystemOperationContext( - file_system_context_.get(), dest_file_util_); - context->set_src_origin_url(dest_origin_url_); - context->set_src_type(dest_type_); - context->set_allowed_bytes_growth(allowed_bytes_growth_); - return context; -} +FileSystemOperationContext::~FileSystemOperationContext() {} } // namespace fileapi diff --git a/webkit/fileapi/file_system_operation_context.h b/webkit/fileapi/file_system_operation_context.h index e61aac8..8901cb1 100644 --- a/webkit/fileapi/file_system_operation_context.h +++ b/webkit/fileapi/file_system_operation_context.h @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 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. @@ -17,91 +17,22 @@ class FileSystemContext; class FileSystemOperationContext { public: - // The |file_util| parameter is so that unit tests can force their own - // preferred class in for both src and dest FSFU; in general these will get - // set later by the FileSystemOperation. - FileSystemOperationContext(FileSystemContext* context, - FileSystemFileUtil* file_util); + FileSystemOperationContext(FileSystemContext* context); ~FileSystemOperationContext(); FileSystemContext* file_system_context() const { return file_system_context_.get(); } - void set_src_file_util(FileSystemFileUtil* util) { - DCHECK(!src_file_util_); - src_file_util_ = util; - } - - FileSystemFileUtil* src_file_util() const { - return src_file_util_; - } - - void set_dest_file_util(FileSystemFileUtil* util) { - DCHECK(!dest_file_util_); - dest_file_util_ = util; - } - - FileSystemFileUtil* dest_file_util() const { - return dest_file_util_; - } - - void set_src_origin_url(const GURL& url) { - src_origin_url_ = url; - } - - const GURL& src_origin_url() const { - return src_origin_url_; - } - - void set_dest_origin_url(const GURL& url) { - dest_origin_url_ = url; - } - - const GURL& dest_origin_url() const { - return dest_origin_url_; - } - - FileSystemType src_type() const { - return src_type_; - } - - void set_src_type(FileSystemType src_type) { - src_type_ = src_type; - } - - FileSystemType dest_type() const { - return dest_type_; - } - - void set_dest_type(FileSystemType dest_type) { - dest_type_ = dest_type; - } - void set_allowed_bytes_growth(const int64& allowed_bytes_growth) { allowed_bytes_growth_ = allowed_bytes_growth; } - int64 allowed_bytes_growth() const { return allowed_bytes_growth_; } - FileSystemOperationContext* CreateInheritedContextForDest() const; - private: scoped_refptr file_system_context_; - // These *_file_util_ are not "owned" by FileSystemOperationContext. They - // are supposed to be pointers to objects that will outlive us. - FileSystemFileUtil* src_file_util_; - FileSystemFileUtil* dest_file_util_; - GURL src_origin_url_; // Also used for any single-path operation. - GURL dest_origin_url_; - FileSystemType src_type_; // Also used for any single-path operation. - FileSystemType dest_type_; int64 allowed_bytes_growth_; - - // Used for delayed operation by quota. - FilePath src_virtual_path_; // Also used for any single-path operation. - FilePath dest_virtual_path_; }; } // namespace fileapi diff --git a/webkit/fileapi/file_system_operation_unittest.cc b/webkit/fileapi/file_system_operation_unittest.cc index b8b86c4..15f0d2b 100644 --- a/webkit/fileapi/file_system_operation_unittest.cc +++ b/webkit/fileapi/file_system_operation_unittest.cc @@ -149,8 +149,7 @@ FilePath ASCIIToFilePath(const std::string& str) { } // namespace (anonymous) -// Test class for FileSystemOperation. Note that this just tests low-level -// operations but doesn't test OpenFileSystem. +// Test class for FileSystemOperation. class FileSystemOperationTest : public testing::Test, public base::SupportsWeakPtr { diff --git a/webkit/fileapi/file_system_path.cc b/webkit/fileapi/file_system_path.cc new file mode 100644 index 0000000..ed2d89d --- /dev/null +++ b/webkit/fileapi/file_system_path.cc @@ -0,0 +1,40 @@ +// Copyright (c) 2012 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.h" + +#include "webkit/fileapi/file_system_types.h" + +namespace fileapi { + +FileSystemPath::FileSystemPath() + : type_(kFileSystemTypeUnknown), + file_util_(NULL) {} + +FileSystemPath::FileSystemPath( + const GURL& origin, + FileSystemType type, + const FilePath& internal_path, + FileSystemFileUtil* file_util) + : origin_(origin), + type_(type), + internal_path_(internal_path), + file_util_(file_util) {} + +FileSystemPath::~FileSystemPath() {} + +FileSystemPath FileSystemPath::WithInternalPath(const FilePath& internal_path) + const { + FileSystemPath new_path(*this); + new_path.set_internal_path(internal_path); + return new_path; +} + +bool FileSystemPath::operator==(const FileSystemPath& that) const { + return origin_ == that.origin_ && + type_ == that.type_ && + internal_path_ == that.internal_path_; +} + +} // namespace fileapi diff --git a/webkit/fileapi/file_system_path.h b/webkit/fileapi/file_system_path.h new file mode 100644 index 0000000..7a9e9fe --- /dev/null +++ b/webkit/fileapi/file_system_path.h @@ -0,0 +1,94 @@ +// Copyright (c) 2012 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. + +#ifndef WEBKIT_FILEAPI_FILE_SYSTEM_PATH_H_ +#define WEBKIT_FILEAPI_FILE_SYSTEM_PATH_H_ + +#include "base/file_path.h" +#include "base/platform_file.h" +#include "googleurl/src/gurl.h" +#include "webkit/fileapi/file_system_types.h" + +namespace fileapi { + +class FileSystemFileUtil; + +// A class representing a filesystem path which consists of origin URL, +// type and an internal path used inside the filesystem. The class also has +// a corresponding FileSystemFileUtil by which the filesystem file is +// handled. +// NOTE: If we completely get rid of cross-filesystem operations under +// FileSystemOperation we may end up converting all the FileSystemPath +// occurences back to a FilePath's. +class FileSystemPath { + public: + FileSystemPath(); + FileSystemPath(const GURL& origin, + FileSystemType type, + const FilePath& internal_path, + FileSystemFileUtil* file_util); + ~FileSystemPath(); + + // Gets and sets the origin URL of this filesystem. + const GURL& origin() const { return origin_; } + void set_origin(const GURL& origin) { origin_ = origin; } + + // Gets and sets the type of this filesystem (e.g. FileSystemTypeTemporary). + FileSystemType type() const { return type_; } + void set_type(FileSystemType type) { type_ = type; } + + // Gets and sets the internal path of this filesystem, which is the path + // used to specify the file in the filesystem. The value could be either + // virtual or platform path depending on filesystem types and corresponding + // file_util's. + const FilePath& internal_path() const { return internal_path_; } + void set_internal_path(const FilePath& internal_path) { + internal_path_ = internal_path; + } + + // Gets and sets the FileSystemFileUtil with which the file pointed by this + // FileSystemPath is handled. + FileSystemFileUtil* file_util() const { return file_util_; } + void set_file_util(FileSystemFileUtil* util) { file_util_ = util; } + + // Returns a new FileSystemPath with the given internal_path. + // This doesn't change the calling instance's data. + FileSystemPath WithInternalPath(const FilePath& internal_path) const; + + // Path related convenient methods. + FileSystemPath BaseName() const { + return WithInternalPath(internal_path().BaseName()); + } + FileSystemPath DirName() const { + return WithInternalPath(internal_path().DirName()); + } + FileSystemPath Append(const FilePath& component) const { + return WithInternalPath(internal_path().Append(component)); + } + FileSystemPath Append(const FilePath::StringType& component) const { + return WithInternalPath(internal_path().Append(component)); + } + FileSystemPath AppendASCII(const base::StringPiece& component) const { + return WithInternalPath(internal_path().AppendASCII(component)); + } + bool IsParent(const FileSystemPath& other) const { + return internal_path_.IsParent(other.internal_path()); + } + + bool operator==(const FileSystemPath& that) const; + + private: + GURL origin_; + FileSystemType type_; + FilePath internal_path_; + + // Not owned. + // TODO(kinuko): This needs to be cleaned up; this value doesn't always + // reflect the current FileUtil in underlying filesystems. + FileSystemFileUtil* file_util_; +}; + +} // namespace fileapi + +#endif // WEBKIT_FILEAPI_FILE_SYSTEM_PATH_H_ diff --git a/webkit/fileapi/file_system_quota_client_unittest.cc b/webkit/fileapi/file_system_quota_client_unittest.cc index df0e345..837c479 100644 --- a/webkit/fileapi/file_system_quota_client_unittest.cc +++ b/webkit/fileapi/file_system_quota_client_unittest.cc @@ -119,36 +119,22 @@ class FileSystemQuotaClientTest : public testing::Test { weak_factory_.GetWeakPtr())); } - FilePath GetOriginBasePath(const std::string& origin_url, - quota::StorageType type) { - // Note: this test assumes sandbox_provider impl is used for - // temporary and persistent filesystem. - return file_system_context_->sandbox_provider()-> - GetBaseDirectoryForOriginAndType( - GURL(origin_url), QuotaStorageTypeToFileSystemType(type), true); - } - - FileSystemOperationContext* CreateFileSystemOperationContext( - FileSystemFileUtil* file_util, - const FilePath& virtual_path, - const std::string& origin_url, - quota::StorageType type) { + FileSystemOperationContext* CreateFileSystemOperationContext() { FileSystemOperationContext* context = - new FileSystemOperationContext(file_system_context_, file_util); - context->set_src_origin_url(GURL(origin_url)); - context->set_src_type(QuotaStorageTypeToFileSystemType(type)); + new FileSystemOperationContext(file_system_context_); context->set_allowed_bytes_growth(100000000); return context; } - bool CreateFileSystemDirectory(const FilePath& path, + bool CreateFileSystemDirectory(const FilePath& file_path, const std::string& origin_url, - quota::StorageType type) { - FileSystemFileUtil* file_util = file_system_context_-> - GetFileUtil(QuotaStorageTypeToFileSystemType(type)); + quota::StorageType storage_type) { + FileSystemType type = QuotaStorageTypeToFileSystemType(storage_type); + FileSystemFileUtil* file_util = file_system_context_->GetFileUtil(type); + FileSystemPath path(GURL(origin_url), type, file_path, file_util); scoped_ptr context( - CreateFileSystemOperationContext(file_util, path, origin_url, type)); + CreateFileSystemOperationContext()); base::PlatformFileError result = file_util->CreateDirectory(context.get(), path, false, false); @@ -157,18 +143,20 @@ class FileSystemQuotaClientTest : public testing::Test { return true; } - bool CreateFileSystemFile(const FilePath& path, + bool CreateFileSystemFile(const FilePath& file_path, int64 file_size, const std::string& origin_url, - quota::StorageType type) { - if (path.empty()) + quota::StorageType storage_type) { + if (file_path.empty()) return false; FileSystemFileUtil* file_util = file_system_context_-> sandbox_provider()->GetFileUtil(); + FileSystemType type = QuotaStorageTypeToFileSystemType(storage_type); + FileSystemPath path(GURL(origin_url), type, file_path, file_util); scoped_ptr context( - CreateFileSystemOperationContext(file_util, path, origin_url, type)); + CreateFileSystemOperationContext()); bool created = false; if (base::PLATFORM_FILE_OK != diff --git a/webkit/fileapi/file_system_test_helper.cc b/webkit/fileapi/file_system_test_helper.cc index 0d31f1d..96f50ea 100644 --- a/webkit/fileapi/file_system_test_helper.cc +++ b/webkit/fileapi/file_system_test_helper.cc @@ -106,7 +106,7 @@ FilePath FileSystemTestOriginHelper::GetLocalPath(const FilePath& path) { DCHECK(file_util_); FilePath local_path; scoped_ptr context(NewOperationContext()); - file_util_->GetLocalFilePath(context.get(), path, &local_path); + file_util_->GetLocalFilePath(context.get(), CreatePath(path), &local_path); return local_path; } @@ -125,6 +125,11 @@ FilePath FileSystemTestOriginHelper::GetUsageCachePath() const { sandbox_provider()->GetUsageCachePathForOriginAndType(origin_, type_); } +FileSystemPath FileSystemTestOriginHelper::CreatePath( + const FilePath& path) const { + return FileSystemPath(origin_, type_, path, file_util_); +} + int64 FileSystemTestOriginHelper::GetCachedOriginUsage() const { return FileSystemUsageCache::GetUsage(GetUsageCachePath()); } @@ -147,26 +152,14 @@ FileSystemOperation* FileSystemTestOriginHelper::NewOperation() { new FileSystemOperation(base::MessageLoopProxy::current(), file_system_context_.get()); operation->set_override_file_util(file_util_); - InitializeOperationContext(operation->file_system_operation_context()); return operation; } FileSystemOperationContext* FileSystemTestOriginHelper::NewOperationContext() { DCHECK(file_system_context_.get()); - DCHECK(file_util_); FileSystemOperationContext* context = - new FileSystemOperationContext(file_system_context_.get(), file_util_); - InitializeOperationContext(context); + new FileSystemOperationContext(file_system_context_.get()); return context; } -void FileSystemTestOriginHelper::InitializeOperationContext( - FileSystemOperationContext* context) { - DCHECK(context); - context->set_src_origin_url(origin_); - context->set_src_type(type_); - context->set_dest_origin_url(origin_); - context->set_dest_type(type_); -} - } // namespace fileapi diff --git a/webkit/fileapi/file_system_test_helper.h b/webkit/fileapi/file_system_test_helper.h index 10ec99d..af654ce 100644 --- a/webkit/fileapi/file_system_test_helper.h +++ b/webkit/fileapi/file_system_test_helper.h @@ -12,6 +12,7 @@ #include "base/memory/ref_counted.h" #include "base/memory/scoped_ptr.h" #include "googleurl/src/gurl.h" +#include "webkit/fileapi/file_system_path.h" #include "webkit/fileapi/file_system_types.h" #include "webkit/fileapi/file_system_util.h" #include "webkit/quota/quota_types.h" @@ -56,6 +57,12 @@ class FileSystemTestOriginHelper { GURL GetURLForPath(const FilePath& path) const; FilePath GetUsageCachePath() const; + // Creates a new FileSystemPath for the given |path|. + FileSystemPath CreatePath(const FilePath& path) const; + FileSystemPath CreatePathFromUTF8(const std::string& utf8) const { + return CreatePath(FilePath::FromUTF8Unsafe(utf8)); + } + int64 GetCachedOriginUsage() const; bool RevokeUsageCache() const; @@ -77,8 +84,6 @@ class FileSystemTestOriginHelper { FileSystemFileUtil* file_util() { return file_util_; } private: - void InitializeOperationContext(FileSystemOperationContext* context); - scoped_refptr file_system_context_; const GURL origin_; const FileSystemType type_; diff --git a/webkit/fileapi/file_system_url_request_job_unittest.cc b/webkit/fileapi/file_system_url_request_job_unittest.cc index 6a49af7..5664289 100644 --- a/webkit/fileapi/file_system_url_request_job_unittest.cc +++ b/webkit/fileapi/file_system_url_request_job_unittest.cc @@ -139,12 +139,14 @@ class FileSystemURLRequestJobTest : public testing::Test { } void CreateDirectory(const base::StringPiece& dir_name) { - FilePath path = FilePath().AppendASCII(dir_name); FileSystemFileUtil* file_util = file_system_context_-> sandbox_provider()->GetFileUtil(); - FileSystemOperationContext context(file_system_context_, file_util); - context.set_src_origin_url(GURL("http://remote")); - context.set_src_type(fileapi::kFileSystemTypeTemporary); + FileSystemPath path(GURL("http://remote"), + kFileSystemTypeTemporary, + FilePath().AppendASCII(dir_name), + file_util); + + FileSystemOperationContext context(file_system_context_); context.set_allowed_bytes_growth(1024); ASSERT_EQ(base::PLATFORM_FILE_OK, file_util->CreateDirectory( @@ -156,12 +158,14 @@ class FileSystemURLRequestJobTest : public testing::Test { void WriteFile(const base::StringPiece& file_name, const char* buf, int buf_size) { - FilePath path = FilePath().AppendASCII(file_name); FileSystemFileUtil* file_util = file_system_context_-> sandbox_provider()->GetFileUtil(); - FileSystemOperationContext context(file_system_context_, file_util); - context.set_src_origin_url(GURL("http://remote")); - context.set_src_type(fileapi::kFileSystemTypeTemporary); + FileSystemPath path(GURL("http://remote"), + kFileSystemTypeTemporary, + FilePath().AppendASCII(file_name), + file_util); + + FileSystemOperationContext context(file_system_context_); context.set_allowed_bytes_growth(1024); base::PlatformFile handle = base::kInvalidPlatformFileValue; diff --git a/webkit/fileapi/file_writer_delegate.cc b/webkit/fileapi/file_writer_delegate.cc index 4aafb88..577e796 100644 --- a/webkit/fileapi/file_writer_delegate.cc +++ b/webkit/fileapi/file_writer_delegate.cc @@ -30,12 +30,14 @@ class InitializeTask : public base::RefCountedThreadSafe { public: InitializeTask( base::PlatformFile file, + const FileSystemPath& path, FileSystemOperationContext* context, const InitializeTaskCallback& callback) : origin_message_loop_proxy_( base::MessageLoopProxy::current()), error_code_(base::PLATFORM_FILE_OK), file_(file), + path_(path), context_(*context), callback_(callback) { DCHECK_EQ(false, callback.is_null()); @@ -58,11 +60,10 @@ class InitializeTask : public base::RefCountedThreadSafe { void ProcessOnTargetThread() { DCHECK(context_.file_system_context()); FileSystemQuotaUtil* quota_util = context_.file_system_context()-> - GetQuotaUtil(context_.src_type()); + GetQuotaUtil(path_.type()); if (quota_util) { DCHECK(quota_util->proxy()); - quota_util->proxy()->StartUpdateOrigin( - context_.src_origin_url(), context_.src_type()); + quota_util->proxy()->StartUpdateOrigin(path_.origin(), path_.type()); } if (!base::GetPlatformFileInfo(file_, &file_info_)) error_code_ = base::PLATFORM_FILE_ERROR_FAILED; @@ -75,6 +76,7 @@ class InitializeTask : public base::RefCountedThreadSafe { base::PlatformFileError error_code_; base::PlatformFile file_; + FileSystemPath path_; FileSystemOperationContext context_; InitializeTaskCallback callback_; @@ -84,10 +86,13 @@ class InitializeTask : public base::RefCountedThreadSafe { } // namespace (anonymous) FileWriterDelegate::FileWriterDelegate( - FileSystemOperation* file_system_operation, int64 offset, + FileSystemOperation* file_system_operation, + const FileSystemPath& path, + int64 offset, scoped_refptr proxy) : file_system_operation_(file_system_operation), file_(base::kInvalidPlatformFileValue), + path_(path), offset_(offset), proxy_(proxy), bytes_written_backlog_(0), @@ -132,7 +137,8 @@ void FileWriterDelegate::Start(base::PlatformFile file, request_ = request; scoped_refptr relay = new InitializeTask( - file_, file_system_operation_context(), + file_, path_, + file_system_operation_context(), base::Bind(&FileWriterDelegate::OnGetFileInfoAndCallStartUpdate, weak_factory_.GetWeakPtr())); relay->Start(proxy_, FROM_HERE); @@ -268,11 +274,8 @@ void FileWriterDelegate::OnError(base::PlatformFileError error) { request_->set_delegate(NULL); request_->Cancel(); - if (quota_util()) { - quota_util()->proxy()->EndUpdateOrigin( - file_system_operation_context()->src_origin_url(), - file_system_operation_context()->src_type()); - } + if (quota_util()) + quota_util()->proxy()->EndUpdateOrigin(path_.origin(), path_.type()); file_system_operation_->DidWrite(error, 0, true); } @@ -287,8 +290,7 @@ void FileWriterDelegate::OnProgress(int bytes_written, bool done) { overlapped = size_ - total_bytes_written_ - offset_; quota_util()->proxy()->UpdateOriginUsage( file_system_operation_->file_system_context()->quota_manager_proxy(), - file_system_operation_context()->src_origin_url(), - file_system_operation_context()->src_type(), + path_.origin(), path_.type(), bytes_written - overlapped); } static const int kMinProgressDelayMS = 200; @@ -299,13 +301,8 @@ void FileWriterDelegate::OnProgress(int bytes_written, bool done) { bytes_written += bytes_written_backlog_; last_progress_event_time_ = currentTime; bytes_written_backlog_ = 0; - if (done && quota_util()) { - if (quota_util()) { - quota_util()->proxy()->EndUpdateOrigin( - file_system_operation_context()->src_origin_url(), - file_system_operation_context()->src_type()); - } - } + if (done && quota_util()) + quota_util()->proxy()->EndUpdateOrigin(path_.origin(), path_.type()); file_system_operation_->DidWrite( base::PLATFORM_FILE_OK, bytes_written, done); return; @@ -325,7 +322,7 @@ FileSystemQuotaUtil* FileWriterDelegate::quota_util() const { DCHECK(file_system_operation_->file_system_context()); DCHECK(file_system_operation_->file_system_operation_context()); return file_system_operation_->file_system_context()->GetQuotaUtil( - file_system_operation_context()->src_type()); + path_.type()); } } // namespace fileapi diff --git a/webkit/fileapi/file_writer_delegate.h b/webkit/fileapi/file_writer_delegate.h index bd33163..dbb2d7c 100644 --- a/webkit/fileapi/file_writer_delegate.h +++ b/webkit/fileapi/file_writer_delegate.h @@ -14,6 +14,7 @@ #include "net/base/file_stream.h" #include "net/base/io_buffer.h" #include "net/url_request/url_request.h" +#include "webkit/fileapi/file_system_path.h" namespace fileapi { @@ -25,6 +26,7 @@ class FileWriterDelegate : public net::URLRequest::Delegate { public: FileWriterDelegate( FileSystemOperation* write_operation, + const FileSystemPath& path, int64 offset, scoped_refptr proxy); virtual ~FileWriterDelegate(); @@ -66,6 +68,7 @@ class FileWriterDelegate : public net::URLRequest::Delegate { FileSystemOperation* file_system_operation_; base::PlatformFile file_; + FileSystemPath path_; int64 size_; int64 offset_; scoped_refptr proxy_; diff --git a/webkit/fileapi/file_writer_delegate_unittest.cc b/webkit/fileapi/file_writer_delegate_unittest.cc index efde1e7..82ac10b 100644 --- a/webkit/fileapi/file_writer_delegate_unittest.cc +++ b/webkit/fileapi/file_writer_delegate_unittest.cc @@ -114,6 +114,7 @@ class FileWriterDelegateTest : public PlatformTest { result_.reset(new Result()); file_writer_delegate_.reset(new FileWriterDelegate( CreateNewOperation(result_.get(), allowed_growth), + test_helper_.CreatePath(file_path_), offset, base::MessageLoopProxy::current())); request_.reset(new net::URLRequest(blob_url, file_writer_delegate_.get())); } @@ -321,6 +322,7 @@ TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimitConcurrent) { result2.reset(new Result()); file_writer_delegate2.reset(new FileWriterDelegate( CreateNewOperation(result2.get(), QuotaFileUtil::kNoLimit), + test_helper_.CreatePath(file_path2), 0, base::MessageLoopProxy::current())); request2.reset(new net::URLRequest(kBlobURL2, file_writer_delegate2.get())); diff --git a/webkit/fileapi/local_file_util.cc b/webkit/fileapi/local_file_util.cc index 68b9c64..0e0cb69 100644 --- a/webkit/fileapi/local_file_util.cc +++ b/webkit/fileapi/local_file_util.cc @@ -9,6 +9,7 @@ #include "webkit/fileapi/file_system_context.h" #include "webkit/fileapi/file_system_mount_point_provider.h" #include "webkit/fileapi/file_system_operation_context.h" +#include "webkit/fileapi/file_system_path.h" #include "webkit/fileapi/file_system_types.h" #include "webkit/fileapi/file_system_util.h" @@ -69,12 +70,10 @@ LocalFileUtil::~LocalFileUtil() { PlatformFileError LocalFileUtil::CreateOrOpen( FileSystemOperationContext* context, - const FilePath& file_path, int file_flags, + const FileSystemPath& path, int file_flags, PlatformFile* file_handle, bool* created) { - FilePath local_path = - GetLocalPath(context, context->src_origin_url(), context->src_type(), - file_path); - if (local_path.empty()) + FileSystemPath local_path = GetLocalPath(context, path); + if (local_path.internal_path().empty()) return base::PLATFORM_FILE_ERROR_INVALID_OPERATION; return underlying_file_util()->CreateOrOpen( context, local_path, file_flags, file_handle, created); @@ -82,12 +81,10 @@ PlatformFileError LocalFileUtil::CreateOrOpen( PlatformFileError LocalFileUtil::EnsureFileExists( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, bool* created) { - FilePath local_path = - GetLocalPath(context, context->src_origin_url(), context->src_type(), - file_path); - if (local_path.empty()) + FileSystemPath local_path = GetLocalPath(context, path); + if (local_path.internal_path().empty()) return base::PLATFORM_FILE_ERROR_INVALID_OPERATION; return underlying_file_util()->EnsureFileExists( context, local_path, created); @@ -95,13 +92,11 @@ PlatformFileError LocalFileUtil::EnsureFileExists( PlatformFileError LocalFileUtil::CreateDirectory( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, bool exclusive, bool recursive) { - FilePath local_path = - GetLocalPath(context, context->src_origin_url(), context->src_type(), - file_path); - if (local_path.empty()) + FileSystemPath local_path = GetLocalPath(context, path); + if (local_path.internal_path().empty()) return base::PLATFORM_FILE_ERROR_INVALID_OPERATION; return underlying_file_util()->CreateDirectory( context, local_path, exclusive, recursive); @@ -109,13 +104,11 @@ PlatformFileError LocalFileUtil::CreateDirectory( PlatformFileError LocalFileUtil::GetFileInfo( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, base::PlatformFileInfo* file_info, FilePath* platform_file_path) { - FilePath local_path = - GetLocalPath(context, context->src_origin_url(), context->src_type(), - file_path); - if (local_path.empty()) + FileSystemPath local_path = GetLocalPath(context, path); + if (local_path.internal_path().empty()) return base::PLATFORM_FILE_ERROR_INVALID_OPERATION; return underlying_file_util()->GetFileInfo( context, local_path, file_info, platform_file_path); @@ -123,13 +116,11 @@ PlatformFileError LocalFileUtil::GetFileInfo( PlatformFileError LocalFileUtil::ReadDirectory( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, std::vector* entries) { // TODO(kkanetkar): Implement directory read in multiple chunks. - FilePath local_path = - GetLocalPath(context, context->src_origin_url(), context->src_type(), - file_path); - if (local_path.empty()) + FileSystemPath local_path = GetLocalPath(context, path); + if (local_path.internal_path().empty()) return base::PLATFORM_FILE_ERROR_INVALID_OPERATION; return underlying_file_util()->ReadDirectory( context, local_path, entries); @@ -137,14 +128,12 @@ PlatformFileError LocalFileUtil::ReadDirectory( FileSystemFileUtil::AbstractFileEnumerator* LocalFileUtil::CreateFileEnumerator( FileSystemOperationContext* context, - const FilePath& root_path) { - FilePath local_path = - GetLocalPath(context, context->src_origin_url(), context->src_type(), - root_path); - if (local_path.empty()) + const FileSystemPath& root_path) { + FileSystemPath local_path = GetLocalPath(context, root_path); + if (local_path.internal_path().empty()) return new EmptyFileEnumerator(); return new LocalFileEnumerator( - local_path, root_path, true, + local_path.internal_path(), root_path.internal_path(), true, static_cast( file_util::FileEnumerator::FILES | file_util::FileEnumerator::DIRECTORIES)); @@ -152,27 +141,23 @@ FileSystemFileUtil::AbstractFileEnumerator* LocalFileUtil::CreateFileEnumerator( PlatformFileError LocalFileUtil::GetLocalFilePath( FileSystemOperationContext* context, - const FilePath& virtual_path, - FilePath* local_path) { - FilePath path = - GetLocalPath(context, context->src_origin_url(), context->src_type(), - virtual_path); - if (path.empty()) + const FileSystemPath& file_system_path, + FilePath* local_file_path) { + FileSystemPath local_path = GetLocalPath(context, file_system_path); + if (local_path.internal_path().empty()) return base::PLATFORM_FILE_ERROR_NOT_FOUND; - *local_path = path; + *local_file_path = local_path.internal_path(); return base::PLATFORM_FILE_OK; } PlatformFileError LocalFileUtil::Touch( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, const base::Time& last_access_time, const base::Time& last_modified_time) { - FilePath local_path = - GetLocalPath(context, context->src_origin_url(), context->src_type(), - file_path); - if (local_path.empty()) + FileSystemPath local_path = GetLocalPath(context, path); + if (local_path.internal_path().empty()) return base::PLATFORM_FILE_ERROR_INVALID_OPERATION; return underlying_file_util()->Touch( context, local_path, last_access_time, last_modified_time); @@ -180,12 +165,10 @@ PlatformFileError LocalFileUtil::Touch( PlatformFileError LocalFileUtil::Truncate( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, int64 length) { - FilePath local_path = - GetLocalPath(context, context->src_origin_url(), context->src_type(), - file_path); - if (local_path.empty()) + FileSystemPath local_path = GetLocalPath(context, path); + if (local_path.internal_path().empty()) return base::PLATFORM_FILE_ERROR_INVALID_OPERATION; return underlying_file_util()->Truncate( context, local_path, length); @@ -193,11 +176,9 @@ PlatformFileError LocalFileUtil::Truncate( bool LocalFileUtil::PathExists( FileSystemOperationContext* context, - const FilePath& file_path) { - FilePath local_path = - GetLocalPath(context, context->src_origin_url(), context->src_type(), - file_path); - if (local_path.empty()) + const FileSystemPath& path) { + FileSystemPath local_path = GetLocalPath(context, path); + if (local_path.internal_path().empty()) return false; return underlying_file_util()->PathExists( context, local_path); @@ -205,11 +186,9 @@ bool LocalFileUtil::PathExists( bool LocalFileUtil::DirectoryExists( FileSystemOperationContext* context, - const FilePath& file_path) { - FilePath local_path = - GetLocalPath(context, context->src_origin_url(), context->src_type(), - file_path); - if (local_path.empty()) + const FileSystemPath& path) { + FileSystemPath local_path = GetLocalPath(context, path); + if (local_path.internal_path().empty()) return false; return underlying_file_util()->DirectoryExists( context, local_path); @@ -217,11 +196,9 @@ bool LocalFileUtil::DirectoryExists( bool LocalFileUtil::IsDirectoryEmpty( FileSystemOperationContext* context, - const FilePath& file_path) { - FilePath local_path = - GetLocalPath(context, context->src_origin_url(), context->src_type(), - file_path); - if (local_path.empty()) + const FileSystemPath& path) { + FileSystemPath local_path = GetLocalPath(context, path); + if (local_path.internal_path().empty()) return true; return underlying_file_util()->IsDirectoryEmpty( context, local_path); @@ -229,19 +206,15 @@ bool LocalFileUtil::IsDirectoryEmpty( PlatformFileError LocalFileUtil::CopyOrMoveFile( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path, + const FileSystemPath& src_path, + const FileSystemPath& dest_path, bool copy) { // TODO(ericu): If they share a root URL, this could be optimized. - FilePath local_src_path = - GetLocalPath(context, context->src_origin_url(), context->src_type(), - src_file_path); - if (local_src_path.empty()) + FileSystemPath local_src_path = GetLocalPath(context, src_path); + if (local_src_path.internal_path().empty()) return base::PLATFORM_FILE_ERROR_INVALID_OPERATION; - FilePath local_dest_path = - GetLocalPath(context, context->dest_origin_url(), context->dest_type(), - dest_file_path); - if (local_dest_path.empty()) + FileSystemPath local_dest_path = GetLocalPath(context, dest_path); + if (local_dest_path.internal_path().empty()) return base::PLATFORM_FILE_ERROR_INVALID_OPERATION; return underlying_file_util()->CopyOrMoveFile( context, local_src_path, local_dest_path, copy); @@ -250,26 +223,24 @@ PlatformFileError LocalFileUtil::CopyOrMoveFile( // TODO(dmikurube): Make it independent from CopyOrMoveFile. PlatformFileError LocalFileUtil::CopyInForeignFile( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path) { - if (src_file_path.empty()) + const FileSystemPath& underlying_src_path, + const FileSystemPath& dest_path) { + if (underlying_src_path.internal_path().empty()) return base::PLATFORM_FILE_ERROR_INVALID_OPERATION; - FilePath local_dest_path = - GetLocalPath(context, context->dest_origin_url(), context->dest_type(), - dest_file_path); - if (local_dest_path.empty()) + FileSystemPath local_dest_path = GetLocalPath(context, dest_path); + if (local_dest_path.internal_path().empty()) return base::PLATFORM_FILE_ERROR_INVALID_OPERATION; return underlying_file_util()->CopyOrMoveFile( - context, src_file_path, local_dest_path, true); + context, + underlying_src_path, + local_dest_path, true); } PlatformFileError LocalFileUtil::DeleteFile( FileSystemOperationContext* context, - const FilePath& file_path) { - FilePath local_path = - GetLocalPath(context, context->src_origin_url(), context->src_type(), - file_path); - if (local_path.empty()) + const FileSystemPath& path) { + FileSystemPath local_path = GetLocalPath(context, path); + if (local_path.internal_path().empty()) return base::PLATFORM_FILE_ERROR_INVALID_OPERATION; return underlying_file_util()->DeleteFile( context, local_path); @@ -277,26 +248,25 @@ PlatformFileError LocalFileUtil::DeleteFile( PlatformFileError LocalFileUtil::DeleteSingleDirectory( FileSystemOperationContext* context, - const FilePath& file_path) { - FilePath local_path = - GetLocalPath(context, context->src_origin_url(), context->src_type(), - file_path); - if (local_path.empty()) + const FileSystemPath& path) { + FileSystemPath local_path = GetLocalPath(context, path); + if (local_path.internal_path().empty()) return base::PLATFORM_FILE_ERROR_INVALID_OPERATION; return underlying_file_util()->DeleteSingleDirectory( context, local_path); } -FilePath LocalFileUtil::GetLocalPath( +FileSystemPath LocalFileUtil::GetLocalPath( FileSystemOperationContext* context, - const GURL& origin_url, - FileSystemType type, - const FilePath& virtual_path) { - FilePath root = context->file_system_context()->GetMountPointProvider(type)-> - GetFileSystemRootPathOnFileThread(origin_url, type, virtual_path, false); + const FileSystemPath& path) { + FileSystemMountPointProvider* provider = + context->file_system_context()->GetMountPointProvider(path.type()); + DCHECK(provider); + FilePath root = provider->GetFileSystemRootPathOnFileThread( + path.origin(), path.type(), path.internal_path(), false); if (root.empty()) - return FilePath(); - return root.Append(virtual_path); + return FileSystemPath(); + return path.WithInternalPath(root.Append(path.internal_path())); } } // namespace fileapi diff --git a/webkit/fileapi/local_file_util.h b/webkit/fileapi/local_file_util.h index 1c24ce4..c981183 100644 --- a/webkit/fileapi/local_file_util.h +++ b/webkit/fileapi/local_file_util.h @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 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. @@ -30,6 +30,7 @@ using base::PlatformFile; using base::PlatformFileError; class FileSystemOperationContext; +class FileSystemPath; // An instance of this class is created and owned by *MountPointProvider. class LocalFileUtil : public FileSystemFileUtil { @@ -42,76 +43,74 @@ class LocalFileUtil : public FileSystemFileUtil { virtual PlatformFileError CreateOrOpen( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, int file_flags, PlatformFile* file_handle, bool* created) OVERRIDE; virtual PlatformFileError EnsureFileExists( FileSystemOperationContext* context, - const FilePath& file_path, bool* created) OVERRIDE; + const FileSystemPath& path, bool* created) OVERRIDE; virtual PlatformFileError CreateDirectory( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, bool exclusive, bool recursive) OVERRIDE; virtual PlatformFileError GetFileInfo( FileSystemOperationContext* context, - const FilePath& file, + const FileSystemPath& path, base::PlatformFileInfo* file_info, FilePath* platform_file) OVERRIDE; virtual PlatformFileError ReadDirectory( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, std::vector* entries) OVERRIDE; virtual AbstractFileEnumerator* CreateFileEnumerator( FileSystemOperationContext* context, - const FilePath& root_path) OVERRIDE; + const FileSystemPath& root_path) OVERRIDE; virtual PlatformFileError GetLocalFilePath( FileSystemOperationContext* context, - const FilePath& virtual_file, - FilePath* local_path) OVERRIDE; + const FileSystemPath& file_system_path, + FilePath* local_file_path) OVERRIDE; virtual PlatformFileError Touch( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, const base::Time& last_access_time, const base::Time& last_modified_time) OVERRIDE; virtual PlatformFileError Truncate( FileSystemOperationContext* context, - const FilePath& path, + const FileSystemPath& path, int64 length) OVERRIDE; virtual bool PathExists( FileSystemOperationContext* context, - const FilePath& file_path) OVERRIDE; + const FileSystemPath& path) OVERRIDE; virtual bool DirectoryExists( FileSystemOperationContext* context, - const FilePath& file_path) OVERRIDE; + const FileSystemPath& path) OVERRIDE; virtual bool IsDirectoryEmpty( FileSystemOperationContext* context, - const FilePath& file_path) OVERRIDE; + const FileSystemPath& path) OVERRIDE; virtual PlatformFileError CopyOrMoveFile( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path, + const FileSystemPath& src_path, + const FileSystemPath& dest_path, bool copy) OVERRIDE; virtual PlatformFileError CopyInForeignFile( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path) OVERRIDE; + const FileSystemPath& underlying_src_path, + const FileSystemPath& dest_path) OVERRIDE; virtual PlatformFileError DeleteFile( FileSystemOperationContext* context, - const FilePath& file_path) OVERRIDE; + const FileSystemPath& path) OVERRIDE; virtual PlatformFileError DeleteSingleDirectory( FileSystemOperationContext* context, - const FilePath& file_path) OVERRIDE; + const FileSystemPath& path) OVERRIDE; private: - // Given the filesystem's root URL and a virtual path, produces a real, full - // local path. - FilePath GetLocalPath( + // Given the filesystem path, produces a real, full local path for the + // underlying filesystem (which is usually the native filesystem). + FileSystemPath GetLocalPath( FileSystemOperationContext* context, - const GURL& origin_url, - FileSystemType type, - const FilePath& virtual_path); + const FileSystemPath& path); DISALLOW_COPY_AND_ASSIGN(LocalFileUtil); }; diff --git a/webkit/fileapi/local_file_util_unittest.cc b/webkit/fileapi/local_file_util_unittest.cc index e1a138e..4851dc9 100644 --- a/webkit/fileapi/local_file_util_unittest.cc +++ b/webkit/fileapi/local_file_util_unittest.cc @@ -47,8 +47,8 @@ class LocalFileUtilTest : public testing::Test { return local_file_util_.get(); } - static FilePath Path(const std::string& file_name) { - return FilePath().AppendASCII(file_name); + FileSystemPath Path(const std::string& file_name) { + return test_helper_.CreatePathFromUTF8(file_name); } FilePath LocalPath(const char *file_name) { diff --git a/webkit/fileapi/native_file_util.cc b/webkit/fileapi/native_file_util.cc index b87fca7..a30ac1c 100644 --- a/webkit/fileapi/native_file_util.cc +++ b/webkit/fileapi/native_file_util.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 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. @@ -51,14 +51,14 @@ bool NativeFileEnumerator::IsDirectory() { PlatformFileError NativeFileUtil::CreateOrOpen( FileSystemOperationContext* unused, - const FilePath& file_path, int file_flags, + const FileSystemPath& path, int file_flags, PlatformFile* file_handle, bool* created) { - if (!file_util::DirectoryExists(file_path.DirName())) { + if (!file_util::DirectoryExists(path.internal_path().DirName())) { // If its parent does not exist, should return NOT_FOUND error. return base::PLATFORM_FILE_ERROR_NOT_FOUND; } PlatformFileError error_code = base::PLATFORM_FILE_OK; - *file_handle = base::CreatePlatformFile(file_path, file_flags, + *file_handle = base::CreatePlatformFile(path.internal_path(), file_flags, created, &error_code); return error_code; } @@ -73,16 +73,16 @@ PlatformFileError NativeFileUtil::Close( PlatformFileError NativeFileUtil::EnsureFileExists( FileSystemOperationContext* unused, - const FilePath& file_path, + const FileSystemPath& path, bool* created) { - if (!file_util::DirectoryExists(file_path.DirName())) + if (!file_util::DirectoryExists(path.internal_path().DirName())) // If its parent does not exist, should return NOT_FOUND error. return base::PLATFORM_FILE_ERROR_NOT_FOUND; PlatformFileError error_code = base::PLATFORM_FILE_OK; - // Tries to create the |file_path| exclusively. This should fail + // Tries to create the |path| exclusively. This should fail // with base::PLATFORM_FILE_ERROR_EXISTS if the path already exists. PlatformFile handle = base::CreatePlatformFile( - file_path, + path.internal_path(), base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_READ, created, &error_code); if (error_code == base::PLATFORM_FILE_ERROR_EXISTS) { @@ -98,56 +98,57 @@ PlatformFileError NativeFileUtil::EnsureFileExists( PlatformFileError NativeFileUtil::CreateDirectory( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, bool exclusive, bool recursive) { // If parent dir of file doesn't exist. - if (!recursive && !file_util::PathExists(file_path.DirName())) + if (!recursive && !file_util::PathExists(path.internal_path().DirName())) return base::PLATFORM_FILE_ERROR_NOT_FOUND; - bool path_exists = file_util::PathExists(file_path); + bool path_exists = file_util::PathExists(path.internal_path()); if (exclusive && path_exists) return base::PLATFORM_FILE_ERROR_EXISTS; // If file exists at the path. - if (path_exists && !file_util::DirectoryExists(file_path)) + if (path_exists && !file_util::DirectoryExists(path.internal_path())) return base::PLATFORM_FILE_ERROR_EXISTS; - if (!file_util::CreateDirectory(file_path)) + if (!file_util::CreateDirectory(path.internal_path())) return base::PLATFORM_FILE_ERROR_FAILED; return base::PLATFORM_FILE_OK; } PlatformFileError NativeFileUtil::GetFileInfo( FileSystemOperationContext* unused, - const FilePath& file_path, + const FileSystemPath& path, base::PlatformFileInfo* file_info, FilePath* platform_file_path) { - if (!file_util::PathExists(file_path)) + if (!file_util::PathExists(path.internal_path())) return base::PLATFORM_FILE_ERROR_NOT_FOUND; // TODO(rkc): Fix this hack once we have refactored file_util to handle // symlinks correctly. // http://code.google.com/p/chromium-os/issues/detail?id=15948 - if (file_util::IsLink(file_path)) + if (file_util::IsLink(path.internal_path())) return base::PLATFORM_FILE_ERROR_NOT_FOUND; - if (!file_util::GetFileInfo(file_path, file_info)) + if (!file_util::GetFileInfo(path.internal_path(), file_info)) return base::PLATFORM_FILE_ERROR_FAILED; - *platform_file_path = file_path; + *platform_file_path = path.internal_path(); return base::PLATFORM_FILE_OK; } PlatformFileError NativeFileUtil::ReadDirectory( FileSystemOperationContext* unused, - const FilePath& file_path, + const FileSystemPath& path, std::vector* entries) { // TODO(kkanetkar): Implement directory read in multiple chunks. - if (!file_util::DirectoryExists(file_path)) + if (!file_util::DirectoryExists(path.internal_path())) return base::PLATFORM_FILE_ERROR_NOT_FOUND; file_util::FileEnumerator file_enum( - file_path, false, static_cast( - file_util::FileEnumerator::FILES | - file_util::FileEnumerator::DIRECTORIES)); + path.internal_path(), false, + static_cast( + file_util::FileEnumerator::FILES | + file_util::FileEnumerator::DIRECTORIES)); FilePath current; while (!(current = file_enum.Next()).empty()) { base::FileUtilProxy::Entry entry; @@ -164,7 +165,7 @@ PlatformFileError NativeFileUtil::ReadDirectory( // http://code.google.com/p/chromium-os/issues/detail?id=15948 // This currently just prevents a file from showing up at all // if it's a link, hence preventing arbitary 'read' exploits. - if (!file_util::IsLink(file_path.Append(entry.name))) + if (!file_util::IsLink(path.internal_path().Append(entry.name))) entries->push_back(entry); } return base::PLATFORM_FILE_OK; @@ -173,40 +174,41 @@ PlatformFileError NativeFileUtil::ReadDirectory( FileSystemFileUtil::AbstractFileEnumerator* NativeFileUtil::CreateFileEnumerator( FileSystemOperationContext* unused, - const FilePath& root_path) { + const FileSystemPath& root_path) { return new NativeFileEnumerator( - root_path, true, static_cast( - file_util::FileEnumerator::FILES | - file_util::FileEnumerator::DIRECTORIES)); + root_path.internal_path(), true, + static_cast( + file_util::FileEnumerator::FILES | + file_util::FileEnumerator::DIRECTORIES)); } PlatformFileError NativeFileUtil::GetLocalFilePath( FileSystemOperationContext* unused, - const FilePath& virtual_path, - FilePath* local_path) { - *local_path = virtual_path; + const FileSystemPath& file_system_path, + FilePath* local_file_path) { + *local_file_path = file_system_path.internal_path(); return base::PLATFORM_FILE_OK; } PlatformFileError NativeFileUtil::Touch( FileSystemOperationContext* unused, - const FilePath& file_path, + const FileSystemPath& path, const base::Time& last_access_time, const base::Time& last_modified_time) { if (!file_util::TouchFile( - file_path, last_access_time, last_modified_time)) + path.internal_path(), last_access_time, last_modified_time)) return base::PLATFORM_FILE_ERROR_FAILED; return base::PLATFORM_FILE_OK; } PlatformFileError NativeFileUtil::Truncate( FileSystemOperationContext* unused, - const FilePath& file_path, + const FileSystemPath& path, int64 length) { PlatformFileError error_code(base::PLATFORM_FILE_ERROR_FAILED); PlatformFile file = base::CreatePlatformFile( - file_path, + path.internal_path(), base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE, NULL, &error_code); @@ -222,33 +224,34 @@ PlatformFileError NativeFileUtil::Truncate( bool NativeFileUtil::PathExists( FileSystemOperationContext* unused, - const FilePath& file_path) { - return file_util::PathExists(file_path); + const FileSystemPath& path) { + return file_util::PathExists(path.internal_path()); } bool NativeFileUtil::DirectoryExists( FileSystemOperationContext* unused, - const FilePath& file_path) { - return file_util::DirectoryExists(file_path); + const FileSystemPath& path) { + return file_util::DirectoryExists(path.internal_path()); } bool NativeFileUtil::IsDirectoryEmpty( FileSystemOperationContext* unused, - const FilePath& file_path) { - return file_util::IsDirectoryEmpty(file_path); + const FileSystemPath& path) { + return file_util::IsDirectoryEmpty(path.internal_path()); } PlatformFileError NativeFileUtil::CopyOrMoveFile( FileSystemOperationContext* unused, - const FilePath& src_file_path, - const FilePath& dest_file_path, + const FileSystemPath& src_path, + const FileSystemPath& dest_path, bool copy) { if (copy) { - if (file_util::CopyFile(src_file_path, dest_file_path)) + if (file_util::CopyFile(src_path.internal_path(), + dest_path.internal_path())) return base::PLATFORM_FILE_OK; } else { - DCHECK(!file_util::DirectoryExists(src_file_path)); - if (file_util::Move(src_file_path, dest_file_path)) + DCHECK(!file_util::DirectoryExists(src_path.internal_path())); + if (file_util::Move(src_path.internal_path(), dest_path.internal_path())) return base::PLATFORM_FILE_OK; } return base::PLATFORM_FILE_ERROR_FAILED; @@ -256,37 +259,40 @@ PlatformFileError NativeFileUtil::CopyOrMoveFile( PlatformFileError NativeFileUtil::CopyInForeignFile( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path) { - return CopyOrMoveFile(context, src_file_path, dest_file_path, true); + const FileSystemPath& underlying_src_path, + const FileSystemPath& dest_path) { + return CopyOrMoveFile(context, + underlying_src_path, + dest_path, + true); } PlatformFileError NativeFileUtil::DeleteFile( FileSystemOperationContext* unused, - const FilePath& file_path) { - if (!file_util::PathExists(file_path)) + const FileSystemPath& path) { + if (!file_util::PathExists(path.internal_path())) return base::PLATFORM_FILE_ERROR_NOT_FOUND; - if (file_util::DirectoryExists(file_path)) + if (file_util::DirectoryExists(path.internal_path())) return base::PLATFORM_FILE_ERROR_NOT_A_FILE; - if (!file_util::Delete(file_path, false)) + if (!file_util::Delete(path.internal_path(), false)) return base::PLATFORM_FILE_ERROR_FAILED; return base::PLATFORM_FILE_OK; } PlatformFileError NativeFileUtil::DeleteSingleDirectory( FileSystemOperationContext* unused, - const FilePath& file_path) { - if (!file_util::PathExists(file_path)) + const FileSystemPath& path) { + if (!file_util::PathExists(path.internal_path())) return base::PLATFORM_FILE_ERROR_NOT_FOUND; - if (!file_util::DirectoryExists(file_path)) { + if (!file_util::DirectoryExists(path.internal_path())) { // TODO(dmikurube): Check if this error code is appropriate. return base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY; } - if (!file_util::IsDirectoryEmpty(file_path)) { + if (!file_util::IsDirectoryEmpty(path.internal_path())) { // TODO(dmikurube): Check if this error code is appropriate. return base::PLATFORM_FILE_ERROR_NOT_EMPTY; } - if (!file_util::Delete(file_path, false)) + if (!file_util::Delete(path.internal_path(), false)) return base::PLATFORM_FILE_ERROR_FAILED; return base::PLATFORM_FILE_OK; } diff --git a/webkit/fileapi/native_file_util.h b/webkit/fileapi/native_file_util.h index 5669680..0e2ee05 100644 --- a/webkit/fileapi/native_file_util.h +++ b/webkit/fileapi/native_file_util.h @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 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. @@ -29,7 +29,7 @@ class NativeFileUtil : public FileSystemFileUtil { virtual PlatformFileError CreateOrOpen( FileSystemOperationContext* unused, - const FilePath& file_path, + const FileSystemPath& path, int file_flags, PlatformFile* file_handle, bool* created) OVERRIDE; @@ -38,61 +38,61 @@ class NativeFileUtil : public FileSystemFileUtil { PlatformFile) OVERRIDE; virtual PlatformFileError EnsureFileExists( FileSystemOperationContext* unused, - const FilePath& file_path, bool* created) OVERRIDE; + const FileSystemPath& path, bool* created) OVERRIDE; virtual PlatformFileError CreateDirectory( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, bool exclusive, bool recursive) OVERRIDE; virtual PlatformFileError GetFileInfo( FileSystemOperationContext* unused, - const FilePath& file_, + const FileSystemPath& path, base::PlatformFileInfo* file_info, - FilePath* platform_path) OVERRIDE; + FilePath* platform_file_path) OVERRIDE; virtual PlatformFileError ReadDirectory( FileSystemOperationContext* unused, - const FilePath& file_path, + const FileSystemPath& path, std::vector* entries) OVERRIDE; virtual AbstractFileEnumerator* CreateFileEnumerator( FileSystemOperationContext* unused, - const FilePath& root_path) OVERRIDE; + const FileSystemPath& root_path) OVERRIDE; virtual PlatformFileError GetLocalFilePath( FileSystemOperationContext* unused, - const FilePath& virtual_path, - FilePath* local_path) OVERRIDE; + const FileSystemPath& file_system_path, + FilePath* local_file_path) OVERRIDE; virtual PlatformFileError Touch( FileSystemOperationContext* unused, - const FilePath& file_path, + const FileSystemPath& path, const base::Time& last_access_time, const base::Time& last_modified_time) OVERRIDE; virtual PlatformFileError Truncate( FileSystemOperationContext* unused, - const FilePath& path, + const FileSystemPath& path, int64 length) OVERRIDE; virtual bool PathExists( FileSystemOperationContext* unused, - const FilePath& file_path) OVERRIDE; + const FileSystemPath& path) OVERRIDE; virtual bool DirectoryExists( FileSystemOperationContext* unused, - const FilePath& file_path) OVERRIDE; + const FileSystemPath& path) OVERRIDE; virtual bool IsDirectoryEmpty( FileSystemOperationContext* unused, - const FilePath& file_path) OVERRIDE; + const FileSystemPath& path) OVERRIDE; virtual PlatformFileError CopyOrMoveFile( FileSystemOperationContext* unused, - const FilePath& src_file_path, - const FilePath& dest_file_path, + const FileSystemPath& src_path, + const FileSystemPath& dest_path, bool copy) OVERRIDE; virtual PlatformFileError CopyInForeignFile( FileSystemOperationContext* unused, - const FilePath& src_file_path, - const FilePath& dest_file_path) OVERRIDE; + const FileSystemPath& underlying_src_path, + const FileSystemPath& dest_path) OVERRIDE; virtual PlatformFileError DeleteFile( FileSystemOperationContext* unused, - const FilePath& file_path) OVERRIDE; + const FileSystemPath& path) OVERRIDE; virtual PlatformFileError DeleteSingleDirectory( FileSystemOperationContext* unused, - const FilePath& file_path) OVERRIDE; + const FileSystemPath& path) OVERRIDE; private: DISALLOW_COPY_AND_ASSIGN(NativeFileUtil); diff --git a/webkit/fileapi/obfuscated_file_util.cc b/webkit/fileapi/obfuscated_file_util.cc index 8cb1702..06090d8 100644 --- a/webkit/fileapi/obfuscated_file_util.cc +++ b/webkit/fileapi/obfuscated_file_util.cc @@ -19,11 +19,14 @@ #include "googleurl/src/gurl.h" #include "webkit/fileapi/file_system_context.h" #include "webkit/fileapi/file_system_operation_context.h" +#include "webkit/fileapi/file_system_path.h" #include "webkit/fileapi/file_system_quota_util.h" #include "webkit/fileapi/file_system_util.h" #include "webkit/fileapi/sandbox_mount_point_provider.h" #include "webkit/quota/quota_manager.h" +namespace fileapi { + namespace { const int64 kFlushDelaySeconds = 10 * 60; // 10 minutes @@ -32,17 +35,17 @@ const char kOriginDatabaseName[] = "Origins"; const char kDirectoryDatabaseName[] = "Paths"; void InitFileInfo( - fileapi::FileSystemDirectoryDatabase::FileInfo* file_info, - fileapi::FileSystemDirectoryDatabase::FileId parent_id, + FileSystemDirectoryDatabase::FileInfo* file_info, + FileSystemDirectoryDatabase::FileId parent_id, const FilePath::StringType& file_name) { DCHECK(file_info); file_info->parent_id = parent_id; file_info->name = file_name; } -bool IsRootDirectory(const FilePath& virtual_path) { - return (virtual_path.empty() || - virtual_path.value() == FILE_PATH_LITERAL("/")); +bool IsRootDirectory(const FileSystemPath& virtual_path) { + return (virtual_path.internal_path().empty() || + virtual_path.internal_path().value() == FILE_PATH_LITERAL("/")); } // Costs computed as per crbug.com/86114, based on the LevelDB implementation of @@ -61,7 +64,7 @@ int64 GetPathQuotaUsage( } bool AllocateQuotaForPath( - fileapi::FileSystemOperationContext* context, + FileSystemOperationContext* context, int growth_in_number_of_paths, int64 growth_in_bytes_of_path_length) { int64 growth = GetPathQuotaUsage(growth_in_number_of_paths, @@ -76,23 +79,23 @@ bool AllocateQuotaForPath( } void UpdatePathQuotaUsage( - fileapi::FileSystemOperationContext* context, - const GURL& origin_url, - fileapi::FileSystemType type, + FileSystemOperationContext* context, + const GURL& origin, + FileSystemType type, int growth_in_number_of_paths, // -1, 0, or 1 int64 growth_in_bytes_of_path_length) { int64 growth = GetPathQuotaUsage(growth_in_number_of_paths, growth_in_bytes_of_path_length); - fileapi::FileSystemQuotaUtil* quota_util = + FileSystemQuotaUtil* quota_util = context->file_system_context()->GetQuotaUtil(type); quota::QuotaManagerProxy* quota_manager_proxy = context->file_system_context()->quota_manager_proxy(); - quota_util->UpdateOriginUsageOnFileThread(quota_manager_proxy, origin_url, - type, growth); + quota_util->UpdateOriginUsageOnFileThread( + quota_manager_proxy, origin, type, growth); } -void TouchDirectory(fileapi::FileSystemDirectoryDatabase* db, - fileapi::FileSystemDirectoryDatabase::FileId dir_id) { +void TouchDirectory(FileSystemDirectoryDatabase* db, + FileSystemDirectoryDatabase::FileId dir_id) { DCHECK(db); if (!db->UpdateModificationTime(dir_id, base::Time::Now())) NOTREACHED(); @@ -105,8 +108,6 @@ const FilePath::CharType kPersistentDirectoryName[] = FILE_PATH_LITERAL("p"); } // namespace -namespace fileapi { - using base::PlatformFile; using base::PlatformFileError; @@ -118,8 +119,9 @@ class ObfuscatedFileEnumerator FileSystemDirectoryDatabase* db, FileSystemOperationContext* context, FileSystemFileUtil* underlying_file_util, - const FilePath& virtual_root_path) + const FileSystemPath& virtual_root_path) : base_path_(base_path), + virtual_root_path_(virtual_root_path), db_(db), context_(context), underlying_file_util_(underlying_file_util) { @@ -129,13 +131,14 @@ class ObfuscatedFileEnumerator FileId file_id; FileInfo file_info; - if (!db_->GetFileWithPath(virtual_root_path, &file_id)) + if (!db_->GetFileWithPath(virtual_root_path.internal_path(), &file_id)) return; if (!db_->GetFileInfo(file_id, &file_info)) return; if (!file_info.is_directory()) return; - FileRecord record = { file_id, file_info, virtual_root_path }; + FileRecord record = { file_id, file_info, + virtual_root_path.internal_path() }; display_queue_.push(record); Next(); // Enumerators don't include the directory itself. } @@ -162,7 +165,9 @@ class ObfuscatedFileEnumerator FilePath local_path = base_path_.Append(current_.file_info.data_path); base::PlatformFileError error = underlying_file_util_->GetFileInfo( - context_, local_path, &file_info, &platform_file_path); + context_, + virtual_root_path_.WithInternalPath(local_path), + &file_info, &platform_file_path); if (error != base::PLATFORM_FILE_OK) { LOG(WARNING) << "Lost a backing file."; return 0; @@ -207,6 +212,7 @@ class ObfuscatedFileEnumerator std::queue recurse_queue_; FileRecord current_; FilePath base_path_; + FileSystemPath virtual_root_path_; FileSystemDirectoryDatabase* db_; FileSystemOperationContext* context_; FileSystemFileUtil* underlying_file_util_; @@ -270,31 +276,34 @@ ObfuscatedFileUtil::~ObfuscatedFileUtil() { PlatformFileError ObfuscatedFileUtil::CreateOrOpen( FileSystemOperationContext* context, - const FilePath& virtual_path, int file_flags, + const FileSystemPath& virtual_path, int file_flags, PlatformFile* file_handle, bool* created) { DCHECK(!(file_flags & (base::PLATFORM_FILE_DELETE_ON_CLOSE | base::PLATFORM_FILE_HIDDEN | base::PLATFORM_FILE_EXCLUSIVE_READ | base::PLATFORM_FILE_EXCLUSIVE_WRITE))); FileSystemDirectoryDatabase* db = GetDirectoryDatabase( - context->src_origin_url(), context->src_type(), true); + virtual_path.origin(), virtual_path.type(), true); if (!db) return base::PLATFORM_FILE_ERROR_FAILED; FileId file_id; - if (!db->GetFileWithPath(virtual_path, &file_id)) { + if (!db->GetFileWithPath(virtual_path.internal_path(), &file_id)) { // The file doesn't exist. if (!(file_flags & (base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_OPEN_ALWAYS))) return base::PLATFORM_FILE_ERROR_NOT_FOUND; FileId parent_id; - if (!db->GetFileWithPath(virtual_path.DirName(), &parent_id)) + if (!db->GetFileWithPath(virtual_path.internal_path().DirName(), + &parent_id)) return base::PLATFORM_FILE_ERROR_NOT_FOUND; FileInfo file_info; - InitFileInfo(&file_info, parent_id, virtual_path.BaseName().value()); + InitFileInfo(&file_info, parent_id, + virtual_path.internal_path().BaseName().value()); if (!AllocateQuotaForPath(context, 1, file_info.name.size())) return base::PLATFORM_FILE_ERROR_NO_SPACE; PlatformFileError error = CreateFile( - context, context->src_origin_url(), context->src_type(), FilePath(), - &file_info, file_flags, file_handle); + context, FileSystemPath(), + virtual_path.origin(), virtual_path.type(), &file_info, + file_flags, file_handle); if (created && base::PLATFORM_FILE_OK == error) *created = true; return error; @@ -309,16 +318,15 @@ PlatformFileError ObfuscatedFileUtil::CreateOrOpen( } if (file_info.is_directory()) return base::PLATFORM_FILE_ERROR_NOT_A_FILE; - FilePath local_path = DataPathToLocalPath(context->src_origin_url(), - context->src_type(), file_info.data_path); + FileSystemPath local_path = DataPathToLocalPath( + virtual_path.origin(), virtual_path.type(), file_info.data_path); base::PlatformFileError error = underlying_file_util()->CreateOrOpen( context, local_path, file_flags, file_handle, created); if (error == base::PLATFORM_FILE_ERROR_NOT_FOUND) { // TODO(tzik): Also invalidate on-memory usage cache in UsageTracker. // TODO(tzik): Delete database entry after ensuring the file lost. - context->file_system_context()->GetQuotaUtil(context->src_type())-> - InvalidateUsageCache(context->src_origin_url(), - context->src_type()); + context->file_system_context()->GetQuotaUtil(virtual_path.type())-> + InvalidateUsageCache(virtual_path.origin(), virtual_path.type()); LOG(WARNING) << "Lost a backing file."; error = base::PLATFORM_FILE_ERROR_FAILED; } @@ -327,14 +335,14 @@ PlatformFileError ObfuscatedFileUtil::CreateOrOpen( PlatformFileError ObfuscatedFileUtil::EnsureFileExists( FileSystemOperationContext* context, - const FilePath& virtual_path, + const FileSystemPath& virtual_path, bool* created) { FileSystemDirectoryDatabase* db = GetDirectoryDatabase( - context->src_origin_url(), context->src_type(), true); + virtual_path.origin(), virtual_path.type(), true); if (!db) return base::PLATFORM_FILE_ERROR_FAILED; FileId file_id; - if (db->GetFileWithPath(virtual_path, &file_id)) { + if (db->GetFileWithPath(virtual_path.internal_path(), &file_id)) { FileInfo file_info; if (!db->GetFileInfo(file_id, &file_info)) { NOTREACHED(); @@ -347,15 +355,18 @@ PlatformFileError ObfuscatedFileUtil::EnsureFileExists( return base::PLATFORM_FILE_OK; } FileId parent_id; - if (!db->GetFileWithPath(virtual_path.DirName(), &parent_id)) + if (!db->GetFileWithPath(virtual_path.internal_path().DirName(), &parent_id)) return base::PLATFORM_FILE_ERROR_NOT_FOUND; FileInfo file_info; - InitFileInfo(&file_info, parent_id, virtual_path.BaseName().value()); + InitFileInfo(&file_info, parent_id, + virtual_path.internal_path().BaseName().value()); if (!AllocateQuotaForPath(context, 1, file_info.name.size())) return base::PLATFORM_FILE_ERROR_NO_SPACE; - PlatformFileError error = CreateFile(context, context->src_origin_url(), - context->src_type(), FilePath(), &file_info, 0, NULL); + PlatformFileError error = CreateFile(context, + FileSystemPath(), + virtual_path.origin(), virtual_path.type(), &file_info, + 0, NULL); if (created && base::PLATFORM_FILE_OK == error) *created = true; return error; @@ -363,15 +374,15 @@ PlatformFileError ObfuscatedFileUtil::EnsureFileExists( PlatformFileError ObfuscatedFileUtil::CreateDirectory( FileSystemOperationContext* context, - const FilePath& virtual_path, + const FileSystemPath& virtual_path, bool exclusive, bool recursive) { FileSystemDirectoryDatabase* db = GetDirectoryDatabase( - context->src_origin_url(), context->src_type(), true); + virtual_path.origin(), virtual_path.type(), true); if (!db) return base::PLATFORM_FILE_ERROR_FAILED; FileId file_id; - if (db->GetFileWithPath(virtual_path, &file_id)) { + if (db->GetFileWithPath(virtual_path.internal_path(), &file_id)) { FileInfo file_info; if (exclusive) return base::PLATFORM_FILE_ERROR_EXISTS; @@ -385,7 +396,7 @@ PlatformFileError ObfuscatedFileUtil::CreateDirectory( } std::vector components; - virtual_path.GetComponents(&components); + virtual_path.internal_path().GetComponents(&components); FileId parent_id = 0; size_t index; for (index = 0; index < components.size(); ++index) { @@ -411,8 +422,8 @@ PlatformFileError ObfuscatedFileUtil::CreateDirectory( NOTREACHED(); return base::PLATFORM_FILE_ERROR_FAILED; } - UpdatePathQuotaUsage(context, context->src_origin_url(), - context->src_type(), 1, file_info.name.size()); + UpdatePathQuotaUsage(context, virtual_path.origin(), virtual_path.type(), + 1, file_info.name.size()); if (first) { first = false; TouchDirectory(db, file_info.parent_id); @@ -423,28 +434,30 @@ PlatformFileError ObfuscatedFileUtil::CreateDirectory( PlatformFileError ObfuscatedFileUtil::GetFileInfo( FileSystemOperationContext* context, - const FilePath& virtual_path, + const FileSystemPath& virtual_path, base::PlatformFileInfo* file_info, FilePath* platform_file_path) { FileSystemDirectoryDatabase* db = GetDirectoryDatabase( - context->src_origin_url(), context->src_type(), false); + virtual_path.origin(), virtual_path.type(), false); if (!db) return base::PLATFORM_FILE_ERROR_NOT_FOUND; FileId file_id; - if (!db->GetFileWithPath(virtual_path, &file_id)) + if (!db->GetFileWithPath(virtual_path.internal_path(), &file_id)) return base::PLATFORM_FILE_ERROR_NOT_FOUND; FileInfo local_info; - return GetFileInfoInternal(db, context, file_id, - &local_info, file_info, platform_file_path); + return GetFileInfoInternal(db, context, + virtual_path.origin(), virtual_path.type(), + file_id, &local_info, + file_info, platform_file_path); } PlatformFileError ObfuscatedFileUtil::ReadDirectory( FileSystemOperationContext* context, - const FilePath& virtual_path, + const FileSystemPath& virtual_path, std::vector* entries) { // TODO(kkanetkar): Implement directory read in multiple chunks. FileSystemDirectoryDatabase* db = GetDirectoryDatabase( - context->src_origin_url(), context->src_type(), false); + virtual_path.origin(), virtual_path.type(), false); if (!db) { if (IsRootDirectory(virtual_path)) { // It's the root directory and the database hasn't been initialized yet. @@ -454,7 +467,7 @@ PlatformFileError ObfuscatedFileUtil::ReadDirectory( return base::PLATFORM_FILE_ERROR_NOT_FOUND; } FileId file_id; - if (!db->GetFileWithPath(virtual_path, &file_id)) + if (!db->GetFileWithPath(virtual_path.internal_path(), &file_id)) return base::PLATFORM_FILE_ERROR_NOT_FOUND; FileInfo file_info; if (!db->GetFileInfo(file_id, &file_info)) { @@ -474,8 +487,10 @@ PlatformFileError ObfuscatedFileUtil::ReadDirectory( for (iter = children.begin(); iter != children.end(); ++iter) { base::PlatformFileInfo platform_file_info; FilePath file_path; - if (GetFileInfoInternal(db, context, *iter, - &file_info, &platform_file_info, &file_path) != + if (GetFileInfoInternal(db, context, + virtual_path.origin(), virtual_path.type(), + *iter, &file_info, &platform_file_info, + &file_path) != base::PLATFORM_FILE_OK) { LOG(WARNING) << "Lost a backing file."; // TODO(tzik): We found a file entry in directory database without @@ -497,14 +512,14 @@ PlatformFileError ObfuscatedFileUtil::ReadDirectory( FileSystemFileUtil::AbstractFileEnumerator* ObfuscatedFileUtil::CreateFileEnumerator( FileSystemOperationContext* context, - const FilePath& root_path) { + const FileSystemPath& root_path) { FileSystemDirectoryDatabase* db = GetDirectoryDatabase( - context->src_origin_url(), context->src_type(), false); + root_path.origin(), root_path.type(), false); if (!db) return new FileSystemFileUtil::EmptyFileEnumerator(); return new ObfuscatedFileEnumerator( - GetDirectoryForOriginAndType(context->src_origin_url(), - context->src_type(), false), + GetDirectoryForOriginAndType(root_path.origin(), + root_path.type(), false), db, context, underlying_file_util(), @@ -513,29 +528,27 @@ ObfuscatedFileUtil::CreateFileEnumerator( PlatformFileError ObfuscatedFileUtil::GetLocalFilePath( FileSystemOperationContext* context, - const FilePath& virtual_path, - FilePath* local_path) { - FilePath path = - GetLocalPath(context->src_origin_url(), context->src_type(), - virtual_path); - if (path.empty()) + const FileSystemPath& file_system_path, + FilePath* local_file_path) { + FileSystemPath local_path = GetLocalPath(file_system_path); + if (local_path.internal_path().empty()) return base::PLATFORM_FILE_ERROR_NOT_FOUND; - *local_path = path; + *local_file_path = local_path.internal_path(); return base::PLATFORM_FILE_OK; } PlatformFileError ObfuscatedFileUtil::Touch( FileSystemOperationContext* context, - const FilePath& virtual_path, + const FileSystemPath& virtual_path, const base::Time& last_access_time, const base::Time& last_modified_time) { FileSystemDirectoryDatabase* db = GetDirectoryDatabase( - context->src_origin_url(), context->src_type(), false); + virtual_path.origin(), virtual_path.type(), false); if (!db) return base::PLATFORM_FILE_ERROR_NOT_FOUND; FileId file_id; - if (!db->GetFileWithPath(virtual_path, &file_id)) + if (!db->GetFileWithPath(virtual_path.internal_path(), &file_id)) return base::PLATFORM_FILE_ERROR_NOT_FOUND; FileInfo file_info; @@ -548,39 +561,37 @@ PlatformFileError ObfuscatedFileUtil::Touch( return base::PLATFORM_FILE_ERROR_FAILED; return base::PLATFORM_FILE_OK; } - FilePath data_path = DataPathToLocalPath(context->src_origin_url(), - context->src_type(), file_info.data_path); + FileSystemPath local_path = DataPathToLocalPath( + virtual_path.origin(), virtual_path.type(), file_info.data_path); return underlying_file_util()->Touch( - context, data_path, last_access_time, last_modified_time); + context, local_path, + last_access_time, last_modified_time); } PlatformFileError ObfuscatedFileUtil::Truncate( FileSystemOperationContext* context, - const FilePath& virtual_path, + const FileSystemPath& virtual_path, int64 length) { - FilePath local_path = - GetLocalPath(context->src_origin_url(), context->src_type(), - virtual_path); - if (local_path.empty()) + FileSystemPath local_path = GetLocalPath(virtual_path); + if (local_path.internal_path().empty()) return base::PLATFORM_FILE_ERROR_NOT_FOUND; - return underlying_file_util()->Truncate( - context, local_path, length); + return underlying_file_util()->Truncate(context, local_path, length); } bool ObfuscatedFileUtil::PathExists( FileSystemOperationContext* context, - const FilePath& virtual_path) { + const FileSystemPath& virtual_path) { FileSystemDirectoryDatabase* db = GetDirectoryDatabase( - context->src_origin_url(), context->src_type(), false); + virtual_path.origin(), virtual_path.type(), false); if (!db) return false; FileId file_id; - return db->GetFileWithPath(virtual_path, &file_id); + return db->GetFileWithPath(virtual_path.internal_path(), &file_id); } bool ObfuscatedFileUtil::DirectoryExists( FileSystemOperationContext* context, - const FilePath& virtual_path) { + const FileSystemPath& virtual_path) { if (IsRootDirectory(virtual_path)) { // It's questionable whether we should return true or false for the // root directory of nonexistent origin, but here we return true @@ -592,11 +603,11 @@ bool ObfuscatedFileUtil::DirectoryExists( return true; } FileSystemDirectoryDatabase* db = GetDirectoryDatabase( - context->src_origin_url(), context->src_type(), false); + virtual_path.origin(), virtual_path.type(), false); if (!db) return false; FileId file_id; - if (!db->GetFileWithPath(virtual_path, &file_id)) + if (!db->GetFileWithPath(virtual_path.internal_path(), &file_id)) return false; FileInfo file_info; if (!db->GetFileInfo(file_id, &file_info)) { @@ -608,13 +619,13 @@ bool ObfuscatedFileUtil::DirectoryExists( bool ObfuscatedFileUtil::IsDirectoryEmpty( FileSystemOperationContext* context, - const FilePath& virtual_path) { + const FileSystemPath& virtual_path) { FileSystemDirectoryDatabase* db = GetDirectoryDatabase( - context->src_origin_url(), context->src_type(), false); + virtual_path.origin(), virtual_path.type(), false); if (!db) return true; // Not a great answer, but it's what others do. FileId file_id; - if (!db->GetFileWithPath(virtual_path, &file_id)) + if (!db->GetFileWithPath(virtual_path.internal_path(), &file_id)) return true; // Ditto. FileInfo file_info; if (!db->GetFileInfo(file_id, &file_info)) { @@ -633,22 +644,23 @@ bool ObfuscatedFileUtil::IsDirectoryEmpty( PlatformFileError ObfuscatedFileUtil::CopyOrMoveFile( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path, + const FileSystemPath& src_path, + const FileSystemPath& dest_path, bool copy) { // Cross-filesystem copies and moves should be handled via CopyInForeignFile. - DCHECK(context->src_origin_url() == context->dest_origin_url()); - DCHECK(context->src_type() == context->dest_type()); + DCHECK(src_path.origin() == dest_path.origin()); + DCHECK(src_path.type() == dest_path.type()); FileSystemDirectoryDatabase* db = GetDirectoryDatabase( - context->src_origin_url(), context->src_type(), true); + src_path.origin(), src_path.type(), true); if (!db) return base::PLATFORM_FILE_ERROR_FAILED; FileId src_file_id; - if (!db->GetFileWithPath(src_file_path, &src_file_id)) + if (!db->GetFileWithPath(src_path.internal_path(), &src_file_id)) return base::PLATFORM_FILE_ERROR_NOT_FOUND; FileId dest_file_id; - bool overwrite = db->GetFileWithPath(dest_file_path, &dest_file_id); + bool overwrite = db->GetFileWithPath(dest_path.internal_path(), + &dest_file_id); FileInfo src_file_info; FileInfo dest_file_info; if (!db->GetFileInfo(src_file_id, &src_file_info) || @@ -678,38 +690,38 @@ PlatformFileError ObfuscatedFileUtil::CopyOrMoveFile( * Just update metadata */ if (copy) { - FilePath src_data_path = DataPathToLocalPath(context->src_origin_url(), - context->src_type(), src_file_info.data_path); - if (!underlying_file_util()->PathExists(context, src_data_path)) { + FileSystemPath src_local_path = DataPathToLocalPath( + src_path.origin(), src_path.type(), src_file_info.data_path); + if (!underlying_file_util()->PathExists(context, src_local_path)) { // TODO(tzik): Also invalidate on-memory usage cache in UsageTracker. - context->file_system_context()->GetQuotaUtil(context->src_type())-> - InvalidateUsageCache(context->src_origin_url(), - context->src_type()); + context->file_system_context()->GetQuotaUtil(src_path.type())-> + InvalidateUsageCache(src_path.origin(), src_path.type()); LOG(WARNING) << "Lost a backing file."; return base::PLATFORM_FILE_ERROR_FAILED; } if (overwrite) { - FilePath dest_data_path = DataPathToLocalPath(context->src_origin_url(), - context->src_type(), dest_file_info.data_path); + FileSystemPath dest_local_path = DataPathToLocalPath( + dest_path.origin(), dest_path.type(), dest_file_info.data_path); PlatformFileError error = underlying_file_util()->CopyOrMoveFile(context, - src_data_path, dest_data_path, copy); + src_local_path, dest_local_path, copy); if (error == base::PLATFORM_FILE_OK) TouchDirectory(db, dest_file_info.parent_id); return error; } else { FileId dest_parent_id; - if (!db->GetFileWithPath(dest_file_path.DirName(), &dest_parent_id)) { + if (!db->GetFileWithPath(dest_path.internal_path().DirName(), + &dest_parent_id)) { NOTREACHED(); // We shouldn't be called in this case. return base::PLATFORM_FILE_ERROR_NOT_FOUND; } InitFileInfo(&dest_file_info, dest_parent_id, - dest_file_path.BaseName().value()); + dest_path.internal_path().BaseName().value()); if (!AllocateQuotaForPath(context, 1, dest_file_info.name.size())) return base::PLATFORM_FILE_ERROR_NO_SPACE; - return CreateFile(context, context->dest_origin_url(), - context->dest_type(), src_data_path, &dest_file_info, 0, - NULL); + return CreateFile(context, src_local_path, + dest_path.origin(), dest_path.type(), &dest_file_info, + 0, NULL); } } else { // It's a move. if (overwrite) { @@ -717,37 +729,39 @@ PlatformFileError ObfuscatedFileUtil::CopyOrMoveFile( -static_cast(src_file_info.name.size())); if (!db->OverwritingMoveFile(src_file_id, dest_file_id)) return base::PLATFORM_FILE_ERROR_FAILED; - FilePath dest_data_path = DataPathToLocalPath(context->src_origin_url(), - context->src_type(), dest_file_info.data_path); + FileSystemPath dest_local_path = DataPathToLocalPath( + dest_path.origin(), dest_path.type(), dest_file_info.data_path); if (base::PLATFORM_FILE_OK != - underlying_file_util()->DeleteFile(context, dest_data_path)) + underlying_file_util()->DeleteFile(context, dest_local_path)) LOG(WARNING) << "Leaked a backing file."; - UpdatePathQuotaUsage(context, context->src_origin_url(), - context->src_type(), -1, - -static_cast(src_file_info.name.size())); + UpdatePathQuotaUsage(context, src_path.origin(), src_path.type(), + -1, -static_cast(src_file_info.name.size())); TouchDirectory(db, src_file_info.parent_id); TouchDirectory(db, dest_file_info.parent_id); return base::PLATFORM_FILE_OK; } else { FileId dest_parent_id; - if (!db->GetFileWithPath(dest_file_path.DirName(), &dest_parent_id)) { + if (!db->GetFileWithPath(dest_path.internal_path().DirName(), + &dest_parent_id)) { NOTREACHED(); return base::PLATFORM_FILE_ERROR_FAILED; } + FilePath dest_internal_path = dest_path.internal_path(); + FilePath src_internal_path = src_path.internal_path(); if (!AllocateQuotaForPath( context, 0, - static_cast(dest_file_path.BaseName().value().size()) - - static_cast(src_file_info.name.size()))) + static_cast(dest_internal_path.BaseName().value().size()) + -static_cast(src_file_info.name.size()))) return base::PLATFORM_FILE_ERROR_NO_SPACE; FileId src_parent_id = src_file_info.parent_id; src_file_info.parent_id = dest_parent_id; - src_file_info.name = dest_file_path.BaseName().value(); + src_file_info.name = dest_path.internal_path().BaseName().value(); if (!db->UpdateFileInfo(src_file_id, src_file_info)) return base::PLATFORM_FILE_ERROR_FAILED; UpdatePathQuotaUsage( - context, context->src_origin_url(), context->src_type(), 0, - static_cast(dest_file_path.BaseName().value().size()) - - static_cast(src_file_path.BaseName().value().size())); + context, src_path.origin(), src_path.type(), 0, + static_cast(dest_internal_path.BaseName().value().size()) - + static_cast(src_internal_path.BaseName().value().size())); TouchDirectory(db, src_parent_id); TouchDirectory(db, dest_parent_id); return base::PLATFORM_FILE_OK; @@ -759,14 +773,15 @@ PlatformFileError ObfuscatedFileUtil::CopyOrMoveFile( PlatformFileError ObfuscatedFileUtil::CopyInForeignFile( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path) { + const FileSystemPath& underlying_src_path, + const FileSystemPath& dest_path) { FileSystemDirectoryDatabase* db = GetDirectoryDatabase( - context->dest_origin_url(), context->dest_type(), true); + dest_path.origin(), dest_path.type(), true); if (!db) return base::PLATFORM_FILE_ERROR_FAILED; FileId dest_file_id; - bool overwrite = db->GetFileWithPath(dest_file_path, &dest_file_id); + bool overwrite = db->GetFileWithPath(dest_path.internal_path(), + &dest_file_id); FileInfo dest_file_info; if (overwrite) { if (!db->GetFileInfo(dest_file_id, &dest_file_info) || @@ -774,35 +789,38 @@ PlatformFileError ObfuscatedFileUtil::CopyInForeignFile( NOTREACHED(); return base::PLATFORM_FILE_ERROR_FAILED; } - FilePath dest_data_path = DataPathToLocalPath(context->dest_origin_url(), - context->dest_type(), dest_file_info.data_path); + FileSystemPath dest_local_path = DataPathToLocalPath( + dest_path.origin(), dest_path.type(), dest_file_info.data_path); return underlying_file_util()->CopyOrMoveFile(context, - src_file_path, dest_data_path, true /* copy */); + underlying_src_path, + dest_local_path, true /* copy */); } else { FileId dest_parent_id; - if (!db->GetFileWithPath(dest_file_path.DirName(), &dest_parent_id)) { + if (!db->GetFileWithPath(dest_path.internal_path().DirName(), + &dest_parent_id)) { NOTREACHED(); // We shouldn't be called in this case. return base::PLATFORM_FILE_ERROR_NOT_FOUND; } InitFileInfo(&dest_file_info, dest_parent_id, - dest_file_path.BaseName().value()); + dest_path.internal_path().BaseName().value()); if (!AllocateQuotaForPath(context, 1, dest_file_info.name.size())) return base::PLATFORM_FILE_ERROR_NO_SPACE; - return CreateFile(context, context->dest_origin_url(), - context->dest_type(), src_file_path, &dest_file_info, 0, NULL); + return CreateFile(context, underlying_src_path, + dest_path.origin(), dest_path.type(), &dest_file_info, + 0, NULL); } return base::PLATFORM_FILE_ERROR_FAILED; } PlatformFileError ObfuscatedFileUtil::DeleteFile( FileSystemOperationContext* context, - const FilePath& virtual_path) { + const FileSystemPath& virtual_path) { FileSystemDirectoryDatabase* db = GetDirectoryDatabase( - context->src_origin_url(), context->src_type(), true); + virtual_path.origin(), virtual_path.type(), true); if (!db) return base::PLATFORM_FILE_ERROR_FAILED; FileId file_id; - if (!db->GetFileWithPath(virtual_path, &file_id)) + if (!db->GetFileWithPath(virtual_path.internal_path(), &file_id)) return base::PLATFORM_FILE_ERROR_NOT_FOUND; FileInfo file_info; if (!db->GetFileInfo(file_id, &file_info) || file_info.is_directory()) { @@ -814,12 +832,12 @@ PlatformFileError ObfuscatedFileUtil::DeleteFile( return base::PLATFORM_FILE_ERROR_FAILED; } AllocateQuotaForPath(context, -1, -static_cast(file_info.name.size())); - UpdatePathQuotaUsage(context, context->src_origin_url(), context->src_type(), + UpdatePathQuotaUsage(context, virtual_path.origin(), virtual_path.type(), -1, -static_cast(file_info.name.size())); - FilePath data_path = DataPathToLocalPath(context->src_origin_url(), - context->src_type(), file_info.data_path); + FileSystemPath local_path = DataPathToLocalPath( + virtual_path.origin(), virtual_path.type(), file_info.data_path); if (base::PLATFORM_FILE_OK != - underlying_file_util()->DeleteFile(context, data_path)) + underlying_file_util()->DeleteFile(context, local_path)) LOG(WARNING) << "Leaked a backing file."; TouchDirectory(db, file_info.parent_id); return base::PLATFORM_FILE_OK; @@ -827,13 +845,13 @@ PlatformFileError ObfuscatedFileUtil::DeleteFile( PlatformFileError ObfuscatedFileUtil::DeleteSingleDirectory( FileSystemOperationContext* context, - const FilePath& virtual_path) { + const FileSystemPath& virtual_path) { FileSystemDirectoryDatabase* db = GetDirectoryDatabase( - context->src_origin_url(), context->src_type(), true); + virtual_path.origin(), virtual_path.type(), true); if (!db) return base::PLATFORM_FILE_ERROR_FAILED; FileId file_id; - if (!db->GetFileWithPath(virtual_path, &file_id)) + if (!db->GetFileWithPath(virtual_path.internal_path(), &file_id)) return base::PLATFORM_FILE_ERROR_NOT_FOUND; FileInfo file_info; if (!db->GetFileInfo(file_id, &file_info) || !file_info.is_directory()) { @@ -843,7 +861,7 @@ PlatformFileError ObfuscatedFileUtil::DeleteSingleDirectory( if (!db->RemoveFileInfo(file_id)) return base::PLATFORM_FILE_ERROR_NOT_EMPTY; AllocateQuotaForPath(context, -1, -static_cast(file_info.name.size())); - UpdatePathQuotaUsage(context, context->src_origin_url(), context->src_type(), + UpdatePathQuotaUsage(context, virtual_path.origin(), virtual_path.type(), -1, -static_cast(file_info.name.size())); TouchDirectory(db, file_info.parent_id); return base::PLATFORM_FILE_OK; @@ -1022,6 +1040,8 @@ int64 ObfuscatedFileUtil::ComputeFilePathCost(const FilePath& path) { PlatformFileError ObfuscatedFileUtil::GetFileInfoInternal( FileSystemDirectoryDatabase* db, FileSystemOperationContext* context, + const GURL& origin, + FileSystemType type, FileId file_id, FileInfo* local_info, base::PlatformFileInfo* file_info, @@ -1046,71 +1066,83 @@ PlatformFileError ObfuscatedFileUtil::GetFileInfoInternal( } if (local_info->data_path.empty()) return base::PLATFORM_FILE_ERROR_INVALID_OPERATION; - FilePath data_path = DataPathToLocalPath(context->src_origin_url(), - context->src_type(), local_info->data_path); + FileSystemPath local_path = DataPathToLocalPath( + origin, type, local_info->data_path); return underlying_file_util()->GetFileInfo( - context, data_path, file_info, platform_file_path); + context, local_path, file_info, platform_file_path); } PlatformFileError ObfuscatedFileUtil::CreateFile( FileSystemOperationContext* context, - const GURL& origin_url, FileSystemType type, const FilePath& source_path, - FileInfo* file_info, int file_flags, PlatformFile* handle) { + const FileSystemPath& source_path, + const GURL& dest_origin, + FileSystemType dest_type, + FileInfo* dest_file_info, int file_flags, PlatformFile* handle) { if (handle) *handle = base::kInvalidPlatformFileValue; FileSystemDirectoryDatabase* db = GetDirectoryDatabase( - origin_url, type, true); + dest_origin, dest_type, true); int64 number; if (!db || !db->GetNextInteger(&number)) return base::PLATFORM_FILE_ERROR_FAILED; // We use the third- and fourth-to-last digits as the directory. int64 directory_number = number % 10000 / 100; - // TODO(ericu): local_path is an OS path; underlying_file_util_ isn't - // guaranteed to understand OS paths. - FilePath local_path = - GetDirectoryForOriginAndType(origin_url, type, false); - if (local_path.empty()) + // TODO(ericu): dest_file_path is an OS path; + // underlying_file_util_ isn't guaranteed to understand OS paths. + FilePath dest_file_path = + GetDirectoryForOriginAndType(dest_origin, dest_type, false); + if (dest_file_path.empty()) return base::PLATFORM_FILE_ERROR_FAILED; - local_path = local_path.AppendASCII(StringPrintf("%02" PRIu64, - directory_number)); + dest_file_path = dest_file_path.AppendASCII( + StringPrintf("%02" PRIu64, directory_number)); + FileSystemPath dest_path(dest_origin, dest_type, dest_file_path, + underlying_file_util()); + PlatformFileError error; error = underlying_file_util()->CreateDirectory( - context, local_path, false /* exclusive */, false /* recursive */); + context, + dest_path, + false /* exclusive */, false /* recursive */); if (base::PLATFORM_FILE_OK != error) return error; - local_path = local_path.AppendASCII(StringPrintf("%08" PRIu64, number)); - FilePath data_path = LocalPathToDataPath(origin_url, type, local_path); + + dest_file_path = dest_file_path.AppendASCII( + StringPrintf("%08" PRIu64, number)); + dest_path.set_internal_path(dest_file_path); + + FilePath data_path = LocalPathToDataPath(dest_path); if (data_path.empty()) return base::PLATFORM_FILE_ERROR_FAILED; + bool created = false; - if (!source_path.empty()) { + if (!source_path.internal_path().empty()) { DCHECK(!file_flags); DCHECK(!handle); error = underlying_file_util()->CopyOrMoveFile( - context, source_path, local_path, true /* copy */); + context, source_path, dest_path, true /* copy */); created = true; } else { FilePath path; - underlying_file_util()->GetLocalFilePath(context, local_path, &path); + underlying_file_util()->GetLocalFilePath(context, dest_path, &path); if (file_util::PathExists(path)) { if (!file_util::Delete(path, true)) { NOTREACHED(); return base::PLATFORM_FILE_ERROR_FAILED; } LOG(WARNING) << "A stray file detected"; - context->file_system_context()->GetQuotaUtil(context->src_type())-> - InvalidateUsageCache(context->src_origin_url(), context->src_type()); + context->file_system_context()->GetQuotaUtil(dest_type)-> + InvalidateUsageCache(dest_origin, dest_type); } if (handle) { error = underlying_file_util()->CreateOrOpen( - context, local_path, file_flags, handle, &created); + context, dest_path, file_flags, handle, &created); // If this succeeds, we must close handle on any subsequent error. } else { DCHECK(!file_flags); // file_flags is only used by CreateOrOpen. error = underlying_file_util()->EnsureFileExists( - context, local_path, &created); + context, dest_path, &created); } } if (error != base::PLATFORM_FILE_OK) @@ -1121,61 +1153,65 @@ PlatformFileError ObfuscatedFileUtil::CreateFile( if (handle) { DCHECK_NE(base::kInvalidPlatformFileValue, *handle); base::ClosePlatformFile(*handle); - underlying_file_util()->DeleteFile(context, local_path); + underlying_file_util()->DeleteFile(context, dest_path); } return base::PLATFORM_FILE_ERROR_FAILED; } - file_info->data_path = data_path; + dest_file_info->data_path = data_path; FileId file_id; - if (!db->AddFileInfo(*file_info, &file_id)) { + if (!db->AddFileInfo(*dest_file_info, &file_id)) { if (handle) { DCHECK_NE(base::kInvalidPlatformFileValue, *handle); base::ClosePlatformFile(*handle); } - underlying_file_util()->DeleteFile(context, local_path); + underlying_file_util()->DeleteFile(context, dest_path); return base::PLATFORM_FILE_ERROR_FAILED; } - UpdatePathQuotaUsage(context, origin_url, type, 1, file_info->name.size()); - TouchDirectory(db, file_info->parent_id); + UpdatePathQuotaUsage(context, dest_origin, dest_type, + 1, dest_file_info->name.size()); + TouchDirectory(db, dest_file_info->parent_id); return base::PLATFORM_FILE_OK; } -FilePath ObfuscatedFileUtil::GetLocalPath( - const GURL& origin_url, - FileSystemType type, - const FilePath& virtual_path) { +FileSystemPath ObfuscatedFileUtil::GetLocalPath( + const FileSystemPath& virtual_path) { FileSystemDirectoryDatabase* db = GetDirectoryDatabase( - origin_url, type, false); + virtual_path.origin(), virtual_path.type(), false); if (!db) - return FilePath(); + return FileSystemPath(); FileId file_id; - if (!db->GetFileWithPath(virtual_path, &file_id)) - return FilePath(); + if (!db->GetFileWithPath(virtual_path.internal_path(), &file_id)) + return FileSystemPath(); FileInfo file_info; if (!db->GetFileInfo(file_id, &file_info) || file_info.is_directory()) { NOTREACHED(); - return FilePath(); // Directories have no local path. + return FileSystemPath(); // Directories have no local path. } - return DataPathToLocalPath(origin_url, type, file_info.data_path); + return DataPathToLocalPath(virtual_path.origin(), + virtual_path.type(), + file_info.data_path); } -FilePath ObfuscatedFileUtil::DataPathToLocalPath( +FileSystemPath ObfuscatedFileUtil::DataPathToLocalPath( const GURL& origin, FileSystemType type, const FilePath& data_path) { FilePath root = GetDirectoryForOriginAndType(origin, type, false); if (root.empty()) - return root; - return root.Append(data_path); + return FileSystemPath(origin, type, root, underlying_file_util()); + return FileSystemPath(origin, type, root.Append(data_path), + underlying_file_util()); } FilePath ObfuscatedFileUtil::LocalPathToDataPath( - const GURL& origin, FileSystemType type, const FilePath& local_path) { - FilePath root = GetDirectoryForOriginAndType(origin, type, false); + const FileSystemPath& local_path) { + FilePath root = GetDirectoryForOriginAndType( + local_path.origin(), local_path.type(), false); if (root.empty()) return root; // This removes the root, including the trailing slash, leaving a relative // path. - return FilePath(local_path.value().substr(root.value().length() + 1)); + FilePath internal_path = local_path.internal_path(); + return FilePath(internal_path.value().substr(root.value().length() + 1)); } // TODO: How to do the whole validation-without-creation thing? We may not have diff --git a/webkit/fileapi/obfuscated_file_util.h b/webkit/fileapi/obfuscated_file_util.h index aaef51f..be9fb85 100644 --- a/webkit/fileapi/obfuscated_file_util.h +++ b/webkit/fileapi/obfuscated_file_util.h @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 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. @@ -17,6 +17,7 @@ #include "webkit/fileapi/file_system_directory_database.h" #include "webkit/fileapi/file_system_file_util.h" #include "webkit/fileapi/file_system_origin_database.h" +#include "webkit/fileapi/file_system_path.h" #include "webkit/fileapi/file_system_types.h" namespace base { @@ -68,82 +69,82 @@ class ObfuscatedFileUtil : public FileSystemFileUtil, virtual base::PlatformFileError CreateOrOpen( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, int file_flags, base::PlatformFile* file_handle, bool* created) OVERRIDE; virtual base::PlatformFileError EnsureFileExists( FileSystemOperationContext* context, - const FilePath& file_path, bool* created) OVERRIDE; + const FileSystemPath& path, bool* created) OVERRIDE; virtual base::PlatformFileError CreateDirectory( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, bool exclusive, bool recursive) OVERRIDE; virtual base::PlatformFileError GetFileInfo( FileSystemOperationContext* context, - const FilePath& file, + const FileSystemPath& path, base::PlatformFileInfo* file_info, FilePath* platform_file) OVERRIDE; virtual base::PlatformFileError ReadDirectory( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, std::vector* entries) OVERRIDE; virtual AbstractFileEnumerator* CreateFileEnumerator( FileSystemOperationContext* context, - const FilePath& root_path) OVERRIDE; + const FileSystemPath& root_path) OVERRIDE; virtual base::PlatformFileError GetLocalFilePath( FileSystemOperationContext* context, - const FilePath& virtual_file, - FilePath* local_path) OVERRIDE; + const FileSystemPath& file_system_path, + FilePath* local_file_path) OVERRIDE; virtual base::PlatformFileError Touch( FileSystemOperationContext* context, - const FilePath& file_path, + const FileSystemPath& path, const base::Time& last_access_time, const base::Time& last_modified_time) OVERRIDE; virtual base::PlatformFileError Truncate( FileSystemOperationContext* context, - const FilePath& path, + const FileSystemPath& path, int64 length) OVERRIDE; virtual bool PathExists( FileSystemOperationContext* context, - const FilePath& file_path) OVERRIDE; + const FileSystemPath& path) OVERRIDE; virtual bool DirectoryExists( FileSystemOperationContext* context, - const FilePath& file_path) OVERRIDE; + const FileSystemPath& path) OVERRIDE; virtual bool IsDirectoryEmpty( FileSystemOperationContext* context, - const FilePath& file_path) OVERRIDE; + const FileSystemPath& path) OVERRIDE; virtual base::PlatformFileError CopyOrMoveFile( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path, + const FileSystemPath& src_path, + const FileSystemPath& dest_path, bool copy) OVERRIDE; virtual PlatformFileError CopyInForeignFile( FileSystemOperationContext* context, - const FilePath& src_file_path, - const FilePath& dest_file_path) OVERRIDE; + const FileSystemPath& underlying_src_path, + const FileSystemPath& dest_path) OVERRIDE; virtual base::PlatformFileError DeleteFile( FileSystemOperationContext* context, - const FilePath& file_path) OVERRIDE; + const FileSystemPath& path) OVERRIDE; virtual base::PlatformFileError DeleteSingleDirectory( FileSystemOperationContext* context, - const FilePath& file_path) OVERRIDE; + const FileSystemPath& path) OVERRIDE; // Gets the topmost directory specific to this origin and type. This will // contain both the directory database's files and all the backing file @@ -196,46 +197,48 @@ class ObfuscatedFileUtil : public FileSystemFileUtil, base::PlatformFileError GetFileInfoInternal( FileSystemDirectoryDatabase* db, FileSystemOperationContext* context, + const GURL& origin, + FileSystemType type, FileId file_id, FileInfo* local_info, base::PlatformFileInfo* file_info, FilePath* platform_file_path); // Creates a new file, both the underlying backing file and the entry in the - // database. file_info is an in-out parameter. Supply the name and + // database. |dest_file_info| is an in-out parameter. Supply the name and // parent_id; data_path is ignored. On success, data_path will // always be set to the relative path [from the root of the type-specific // filesystem directory] of a NEW backing file, and handle, if supplied, will // hold open PlatformFile for the backing file, which the caller is - // responsible for closing. If you supply a path in source_path, it will be + // responsible for closing. If you supply a path in |source_path|, it will be // used as a source from which to COPY data. // Caveat: do not supply handle if you're also supplying a data path. It was // easier not to support this, and no code has needed it so far, so it will // DCHECK and handle will hold base::kInvalidPlatformFileValue. base::PlatformFileError CreateFile( FileSystemOperationContext* context, - const GURL& origin_url, FileSystemType type, - const FilePath& source_path, FileInfo* file_info, - int file_flags, base::PlatformFile* handle); - - // Given the filesystem's root URL and a virtual path, produces a real, full - // local path to the underlying data file. This does a database lookup, and - // verifies that the file exists. - FilePath GetLocalPath( - const GURL& origin_url, - FileSystemType type, - const FilePath& virtual_path); + const FileSystemPath& source_path, + const GURL& dest_origin, + FileSystemType dest_type, + FileInfo* dest_file_info, + int file_flags, + base::PlatformFile* handle); + + // Given a virtual path, produces a real, full local path to the + // underlying data file. This does a database lookup (by + // calling DataPathToLocalPath()), and verifies that the file exists. + FileSystemPath GetLocalPath(const FileSystemPath& virtual_path); // This converts from a relative path [as is stored in the FileInfo.data_path - // field] to an absolute local path that can be given to the operating system. - // It does no checks as to whether the file actually exists; it's pure path - // manipulation. - FilePath DataPathToLocalPath( - const GURL& origin, FileSystemType type, const FilePath& data_path); + // field] to an absolute local path that can be given to the underlying + // filesystem (as of now the returned path is assumed to be a platform path). + FileSystemPath DataPathToLocalPath( + const GURL& origin, + FileSystemType type, + const FilePath& data_file_path); // This does the reverse of DataPathToLocalPath. - FilePath LocalPathToDataPath( - const GURL& origin, FileSystemType type, const FilePath& local_path); + FilePath LocalPathToDataPath(const FileSystemPath& local_path); // This returns NULL if |create| flag is false and a filesystem does not // exist for the given |origin_url| and |type|. diff --git a/webkit/fileapi/obfuscated_file_util_unittest.cc b/webkit/fileapi/obfuscated_file_util_unittest.cc index 5f42905..8eb2344 100644 --- a/webkit/fileapi/obfuscated_file_util_unittest.cc +++ b/webkit/fileapi/obfuscated_file_util_unittest.cc @@ -199,6 +199,14 @@ class ObfuscatedFileUtilTest : public testing::Test { int64 usage() const { return usage_; } + FileSystemPath CreatePathFromUTF8(const std::string& path) { + return test_helper_.CreatePathFromUTF8(path); + } + + FileSystemPath CreatePath(const FilePath& path) { + return test_helper_.CreatePath(path); + } + void OnGetUsage(quota::QuotaStatusCode status, int64 usage, int64 unused) { EXPECT_EQ(quota::kQuotaStatusOk, status); quota_status_ = status; @@ -206,7 +214,7 @@ class ObfuscatedFileUtilTest : public testing::Test { } void CheckFileAndCloseHandle( - const FilePath& virtual_path, PlatformFile file_handle) { + const FileSystemPath& virtual_path, PlatformFile file_handle) { scoped_ptr context(NewContext(NULL)); FilePath local_path; EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetLocalFilePath( @@ -265,7 +273,7 @@ class ObfuscatedFileUtilTest : public testing::Test { } void ValidateTestDirectory( - const FilePath& root_path, + const FileSystemPath& root_path, const std::set& files, const std::set& directories) { scoped_ptr context; @@ -287,7 +295,7 @@ class ObfuscatedFileUtilTest : public testing::Test { } void FillTestDirectory( - const FilePath& root_path, + const FileSystemPath& root_path, std::set* files, std::set* directories) { scoped_ptr context; @@ -311,7 +319,9 @@ class ObfuscatedFileUtilTest : public testing::Test { context.reset(NewContext(NULL)); ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->EnsureFileExists( - context.get(), root_path.Append(*iter), &created)); + context.get(), + root_path.Append(*iter), + &created)); ASSERT_TRUE(created); } for (iter = directories->begin(); iter != directories->end(); ++iter) { @@ -325,7 +335,7 @@ class ObfuscatedFileUtilTest : public testing::Test { ValidateTestDirectory(root_path, *files, *directories); } - void TestReadDirectoryHelper(const FilePath& root_path) { + void TestReadDirectoryHelper(const FileSystemPath& root_path) { std::set files; std::set directories; FillTestDirectory(root_path, &files, &directories); @@ -353,7 +363,7 @@ class ObfuscatedFileUtilTest : public testing::Test { } } - void TestTouchHelper(const FilePath& path, bool is_file) { + void TestTouchHelper(const FileSystemPath& path, bool is_file) { base::Time last_access_time = base::Time::Now(); base::Time last_modified_time = base::Time::Now(); @@ -388,9 +398,10 @@ class ObfuscatedFileUtilTest : public testing::Test { void TestCopyInForeignFileHelper(bool overwrite) { ScopedTempDir source_dir; ASSERT_TRUE(source_dir.CreateUniqueTempDir()); - FilePath root_path = source_dir.path(); - FilePath src_path = root_path.AppendASCII("file_name"); - FilePath dest_path(FILE_PATH_LITERAL("new file")); + FilePath root_file_path = source_dir.path(); + FilePath src_file_path = root_file_path.AppendASCII("file_name"); + FileSystemPath dest_path = CreatePathFromUTF8("new file"); + FileSystemPath src_path = CreatePath(src_file_path); int64 src_file_length = 87; base::PlatformFileError error_code; @@ -398,7 +409,7 @@ class ObfuscatedFileUtilTest : public testing::Test { int file_flags = base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE; base::PlatformFile file_handle = base::CreatePlatformFile( - src_path, file_flags, &created, &error_code); + src_file_path, file_flags, &created, &error_code); EXPECT_TRUE(created); ASSERT_EQ(base::PLATFORM_FILE_OK, error_code); ASSERT_NE(base::kInvalidPlatformFileValue, file_handle); @@ -415,7 +426,7 @@ class ObfuscatedFileUtilTest : public testing::Test { } const int64 path_cost = - ObfuscatedFileUtil::ComputeFilePathCost(dest_path); + ObfuscatedFileUtil::ComputeFilePathCost(dest_path.internal_path()); if (!overwrite) { // Verify that file creation requires sufficient quota for the path. context.reset(NewContext(NULL)); @@ -438,7 +449,7 @@ class ObfuscatedFileUtilTest : public testing::Test { FilePath data_path; EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetFileInfo( context.get(), dest_path, &file_info, &data_path)); - EXPECT_NE(data_path, src_path); + EXPECT_NE(data_path, src_file_path); EXPECT_TRUE(FileExists(data_path)); EXPECT_EQ(src_file_length, GetSize(data_path)); @@ -446,14 +457,14 @@ class ObfuscatedFileUtilTest : public testing::Test { ofu()->DeleteFile(context.get(), dest_path)); } - void ClearTimestamp(const FilePath& path) { + void ClearTimestamp(const FileSystemPath& path) { scoped_ptr context(NewContext(NULL)); EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->Touch(context.get(), path, base::Time(), base::Time())); EXPECT_EQ(base::Time(), GetModifiedTime(path)); } - base::Time GetModifiedTime(const FilePath& path) { + base::Time GetModifiedTime(const FileSystemPath& path) { scoped_ptr context(NewContext(NULL)); FilePath data_path; base::PlatformFileInfo file_info; @@ -463,15 +474,15 @@ class ObfuscatedFileUtilTest : public testing::Test { return file_info.last_modified; } - void TestDirectoryTimestampHelper(const FilePath& base_dir, + void TestDirectoryTimestampHelper(const FileSystemPath& base_dir, bool copy, bool overwrite) { scoped_ptr context; - const FilePath src_dir_path(base_dir.AppendASCII("foo_dir")); - const FilePath dest_dir_path(base_dir.AppendASCII("bar_dir")); + const FileSystemPath src_dir_path(base_dir.AppendASCII("foo_dir")); + const FileSystemPath dest_dir_path(base_dir.AppendASCII("bar_dir")); - const FilePath src_file_path(src_dir_path.AppendASCII("hoge")); - const FilePath dest_file_path(dest_dir_path.AppendASCII("fuga")); + const FileSystemPath src_file_path(src_dir_path.AppendASCII("hoge")); + const FileSystemPath dest_file_path(dest_dir_path.AppendASCII("fuga")); context.reset(NewContext(NULL)); EXPECT_EQ(base::PLATFORM_FILE_OK, @@ -524,7 +535,7 @@ class ObfuscatedFileUtilTest : public testing::Test { TEST_F(ObfuscatedFileUtilTest, TestCreateAndDeleteFile) { base::PlatformFile file_handle = base::kInvalidPlatformFileValue; bool created; - FilePath path = FilePath::FromUTF8Unsafe("fake/file"); + FileSystemPath path = CreatePathFromUTF8("fake/file"); scoped_ptr context(NewContext(NULL)); int file_flags = base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE; @@ -537,19 +548,19 @@ TEST_F(ObfuscatedFileUtilTest, TestCreateAndDeleteFile) { EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, ofu()->DeleteFile(context.get(), path)); - path = FilePath::FromUTF8Unsafe("test file"); + path = CreatePathFromUTF8("test file"); // Verify that file creation requires sufficient quota for the path. context.reset(NewContext(NULL)); context->set_allowed_bytes_growth( - ObfuscatedFileUtil::ComputeFilePathCost(path) - 1); + ObfuscatedFileUtil::ComputeFilePathCost(path.internal_path()) - 1); ASSERT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, ofu()->CreateOrOpen( context.get(), path, file_flags, &file_handle, &created)); context.reset(NewContext(NULL)); context->set_allowed_bytes_growth( - ObfuscatedFileUtil::ComputeFilePathCost(path)); + ObfuscatedFileUtil::ComputeFilePathCost(path.internal_path())); ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateOrOpen( context.get(), path, file_flags, &file_handle, &created)); @@ -571,13 +582,14 @@ TEST_F(ObfuscatedFileUtilTest, TestCreateAndDeleteFile) { EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->DeleteFile(context.get(), path)); EXPECT_FALSE(file_util::PathExists(local_path)); - EXPECT_EQ(ObfuscatedFileUtil::ComputeFilePathCost(path), + EXPECT_EQ(ObfuscatedFileUtil::ComputeFilePathCost(path.internal_path()), context->allowed_bytes_growth()); context.reset(NewContext(NULL)); bool exclusive = true; bool recursive = true; - FilePath directory_path = FilePath::FromUTF8Unsafe("series/of/directories"); + FileSystemPath directory_path = CreatePathFromUTF8( + "series/of/directories"); path = directory_path.AppendASCII("file name"); EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory( context.get(), directory_path, exclusive, recursive)); @@ -605,7 +617,7 @@ TEST_F(ObfuscatedFileUtilTest, TestCreateAndDeleteFile) { TEST_F(ObfuscatedFileUtilTest, TestTruncate) { bool created = false; - FilePath path = FilePath::FromUTF8Unsafe("file"); + FileSystemPath path = CreatePathFromUTF8("file"); scoped_ptr context(NewContext(NULL)); EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, @@ -639,7 +651,7 @@ TEST_F(ObfuscatedFileUtilTest, TestTruncate) { } TEST_F(ObfuscatedFileUtilTest, TestEnsureFileExists) { - FilePath path = FilePath::FromUTF8Unsafe("fake/file"); + FileSystemPath path = CreatePathFromUTF8("fake/file"); bool created = false; scoped_ptr context(NewContext(NULL)); EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, @@ -648,17 +660,17 @@ TEST_F(ObfuscatedFileUtilTest, TestEnsureFileExists) { // Verify that file creation requires sufficient quota for the path. context.reset(NewContext(NULL)); - path = FilePath::FromUTF8Unsafe("test file"); + path = CreatePathFromUTF8("test file"); created = false; context->set_allowed_bytes_growth( - ObfuscatedFileUtil::ComputeFilePathCost(path) - 1); + ObfuscatedFileUtil::ComputeFilePathCost(path.internal_path()) - 1); ASSERT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, ofu()->EnsureFileExists(context.get(), path, &created)); ASSERT_FALSE(created); context.reset(NewContext(NULL)); context->set_allowed_bytes_growth( - ObfuscatedFileUtil::ComputeFilePathCost(path)); + ObfuscatedFileUtil::ComputeFilePathCost(path.internal_path())); ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->EnsureFileExists(context.get(), path, &created)); ASSERT_TRUE(created); @@ -671,7 +683,7 @@ TEST_F(ObfuscatedFileUtilTest, TestEnsureFileExists) { ASSERT_FALSE(created); // Also test in a subdirectory. - path = FilePath::FromUTF8Unsafe("path/to/file.txt"); + path = CreatePathFromUTF8("path/to/file.txt"); context.reset(NewContext(NULL)); bool exclusive = true; bool recursive = true; @@ -693,7 +705,7 @@ TEST_F(ObfuscatedFileUtilTest, TestDirectoryOps) { bool exclusive = false; bool recursive = false; - FilePath path = FilePath::FromUTF8Unsafe("foo/bar"); + FileSystemPath path = CreatePathFromUTF8("foo/bar"); EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, ofu()->CreateDirectory( context.get(), path, exclusive, recursive)); @@ -701,7 +713,7 @@ TEST_F(ObfuscatedFileUtilTest, TestDirectoryOps) { EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, ofu()->DeleteSingleDirectory(context.get(), path)); - FilePath root = FilePath::FromUTF8Unsafe(""); + FileSystemPath root = CreatePathFromUTF8(""); context.reset(NewContext(NULL)); EXPECT_FALSE(ofu()->DirectoryExists(context.get(), path)); context.reset(NewContext(NULL)); @@ -756,10 +768,10 @@ TEST_F(ObfuscatedFileUtilTest, TestDirectoryOps) { context->set_allowed_bytes_growth(0); EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->DeleteSingleDirectory(context.get(), path)); - EXPECT_EQ(ObfuscatedFileUtil::ComputeFilePathCost(path), + EXPECT_EQ(ObfuscatedFileUtil::ComputeFilePathCost(path.internal_path()), context->allowed_bytes_growth()); - path = FilePath::FromUTF8Unsafe("foo/bop"); + path = CreatePathFromUTF8("foo/bop"); context.reset(NewContext(NULL)); EXPECT_FALSE(ofu()->DirectoryExists(context.get(), path)); @@ -775,13 +787,13 @@ TEST_F(ObfuscatedFileUtilTest, TestDirectoryOps) { recursive = false; context.reset(NewContext(NULL)); context->set_allowed_bytes_growth( - ObfuscatedFileUtil::ComputeFilePathCost(path) - 1); + ObfuscatedFileUtil::ComputeFilePathCost(path.internal_path()) - 1); EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, ofu()->CreateDirectory( context.get(), path, exclusive, recursive)); context.reset(NewContext(NULL)); context->set_allowed_bytes_growth( - ObfuscatedFileUtil::ComputeFilePathCost(path)); + ObfuscatedFileUtil::ComputeFilePathCost(path.internal_path())); EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory( context.get(), path, exclusive, recursive)); @@ -797,11 +809,11 @@ TEST_F(ObfuscatedFileUtilTest, TestDirectoryOps) { exclusive = true; recursive = false; - path = FilePath::FromUTF8Unsafe("foo"); + path = CreatePathFromUTF8("foo"); EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, ofu()->CreateDirectory( context.get(), path, exclusive, recursive)); - path = FilePath::FromUTF8Unsafe("blah"); + path = CreatePathFromUTF8("blah"); context.reset(NewContext(NULL)); EXPECT_FALSE(ofu()->DirectoryExists(context.get(), path)); @@ -828,22 +840,22 @@ TEST_F(ObfuscatedFileUtilTest, TestReadDirectory) { scoped_ptr context(NewContext(NULL)); bool exclusive = true; bool recursive = true; - FilePath path = FilePath::FromUTF8Unsafe("directory/to/use"); + FileSystemPath path = CreatePathFromUTF8("directory/to/use"); EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory( context.get(), path, exclusive, recursive)); TestReadDirectoryHelper(path); } TEST_F(ObfuscatedFileUtilTest, TestReadRootWithSlash) { - TestReadDirectoryHelper(FilePath::FromUTF8Unsafe("")); + TestReadDirectoryHelper(CreatePathFromUTF8("")); } TEST_F(ObfuscatedFileUtilTest, TestReadRootWithEmptyString) { - TestReadDirectoryHelper(FilePath::FromUTF8Unsafe("/")); + TestReadDirectoryHelper(CreatePathFromUTF8("/")); } TEST_F(ObfuscatedFileUtilTest, TestReadDirectoryOnFile) { - FilePath path = FilePath::FromUTF8Unsafe("file"); + FileSystemPath path = CreatePathFromUTF8("file"); scoped_ptr context(NewContext(NULL)); bool created = false; @@ -860,7 +872,7 @@ TEST_F(ObfuscatedFileUtilTest, TestReadDirectoryOnFile) { } TEST_F(ObfuscatedFileUtilTest, TestTouch) { - FilePath path = FilePath::FromUTF8Unsafe("file"); + FileSystemPath path = CreatePathFromUTF8("file"); scoped_ptr context(NewContext(NULL)); base::Time last_access_time = base::Time::Now(); @@ -883,17 +895,17 @@ TEST_F(ObfuscatedFileUtilTest, TestTouch) { context.reset(NewContext(NULL)); bool exclusive = true; bool recursive = false; - path = FilePath::FromUTF8Unsafe("dir"); + path = CreatePathFromUTF8("dir"); ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(context.get(), path, exclusive, recursive)); TestTouchHelper(path, false); } TEST_F(ObfuscatedFileUtilTest, TestPathQuotas) { - FilePath path = FilePath::FromUTF8Unsafe("fake/file"); + FileSystemPath path = CreatePathFromUTF8("fake/file"); scoped_ptr context(NewContext(NULL)); - path = FilePath::FromUTF8Unsafe("file name"); + path = CreatePathFromUTF8("file name"); context->set_allowed_bytes_growth(5); bool created = false; EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, @@ -903,15 +915,16 @@ TEST_F(ObfuscatedFileUtilTest, TestPathQuotas) { EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->EnsureFileExists(context.get(), path, &created)); EXPECT_TRUE(created); - int64 path_cost = ObfuscatedFileUtil::ComputeFilePathCost(path); + int64 path_cost = ObfuscatedFileUtil::ComputeFilePathCost( + path.internal_path()); EXPECT_EQ(1024 - path_cost, context->allowed_bytes_growth()); context->set_allowed_bytes_growth(1024); bool exclusive = true; bool recursive = true; - path = FilePath::FromUTF8Unsafe("directory/to/use"); + path = CreatePathFromUTF8("directory/to/use"); std::vector components; - path.GetComponents(&components); + path.internal_path().GetComponents(&components); path_cost = 0; for (std::vector::iterator iter = components.begin(); iter != components.end(); ++iter) { @@ -926,8 +939,8 @@ TEST_F(ObfuscatedFileUtilTest, TestPathQuotas) { } TEST_F(ObfuscatedFileUtilTest, TestCopyOrMoveFileNotFound) { - FilePath source_path = FilePath::FromUTF8Unsafe("path0.txt"); - FilePath dest_path = FilePath::FromUTF8Unsafe("path1.txt"); + FileSystemPath source_path = CreatePathFromUTF8("path0.txt"); + FileSystemPath dest_path = CreatePathFromUTF8("path1.txt"); scoped_ptr context(NewContext(NULL)); bool is_copy_not_move = false; @@ -939,7 +952,7 @@ TEST_F(ObfuscatedFileUtilTest, TestCopyOrMoveFileNotFound) { EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, ofu()->CopyOrMoveFile(context.get(), source_path, dest_path, is_copy_not_move)); - source_path = FilePath::FromUTF8Unsafe("dir/dir/file"); + source_path = CreatePathFromUTF8("dir/dir/file"); bool exclusive = true; bool recursive = true; context.reset(NewContext(NULL)); @@ -975,8 +988,8 @@ TEST_F(ObfuscatedFileUtilTest, TestCopyOrMoveFileSuccess) { bool exclusive = false; bool recursive = true; - FilePath source_path = FilePath::FromUTF8Unsafe(test_case.source_path); - FilePath dest_path = FilePath::FromUTF8Unsafe(test_case.dest_path); + FileSystemPath source_path = CreatePathFromUTF8(test_case.source_path); + FileSystemPath dest_path = CreatePathFromUTF8(test_case.dest_path); context.reset(NewContext(NULL)); ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory( @@ -1036,8 +1049,8 @@ TEST_F(ObfuscatedFileUtilTest, TestCopyOrMoveFileSuccess) { } TEST_F(ObfuscatedFileUtilTest, TestCopyPathQuotas) { - FilePath src_path = FilePath::FromUTF8Unsafe("src path"); - FilePath dest_path = FilePath::FromUTF8Unsafe("destination path"); + FileSystemPath src_path = CreatePathFromUTF8("src path"); + FileSystemPath dest_path = CreatePathFromUTF8("destination path"); scoped_ptr context(NewContext(NULL)); bool created = false; ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->EnsureFileExists( @@ -1046,12 +1059,12 @@ TEST_F(ObfuscatedFileUtilTest, TestCopyPathQuotas) { bool is_copy = true; // Copy, no overwrite. context->set_allowed_bytes_growth( - ObfuscatedFileUtil::ComputeFilePathCost(dest_path) - 1); + ObfuscatedFileUtil::ComputeFilePathCost(dest_path.internal_path()) - 1); EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, ofu()->CopyOrMoveFile(context.get(), src_path, dest_path, is_copy)); context.reset(NewContext(NULL)); context->set_allowed_bytes_growth( - ObfuscatedFileUtil::ComputeFilePathCost(dest_path)); + ObfuscatedFileUtil::ComputeFilePathCost(dest_path.internal_path())); EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CopyOrMoveFile(context.get(), src_path, dest_path, is_copy)); @@ -1063,8 +1076,8 @@ TEST_F(ObfuscatedFileUtilTest, TestCopyPathQuotas) { } TEST_F(ObfuscatedFileUtilTest, TestMovePathQuotasWithRename) { - FilePath src_path = FilePath::FromUTF8Unsafe("src path"); - FilePath dest_path = FilePath::FromUTF8Unsafe("destination path"); + FileSystemPath src_path = CreatePathFromUTF8("src path"); + FileSystemPath dest_path = CreatePathFromUTF8("destination path"); scoped_ptr context(NewContext(NULL)); bool created = false; ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->EnsureFileExists( @@ -1074,14 +1087,14 @@ TEST_F(ObfuscatedFileUtilTest, TestMovePathQuotasWithRename) { // Move, rename, no overwrite. context.reset(NewContext(NULL)); context->set_allowed_bytes_growth( - ObfuscatedFileUtil::ComputeFilePathCost(dest_path) - - ObfuscatedFileUtil::ComputeFilePathCost(src_path) - 1); + ObfuscatedFileUtil::ComputeFilePathCost(dest_path.internal_path()) - + ObfuscatedFileUtil::ComputeFilePathCost(src_path.internal_path()) - 1); EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, ofu()->CopyOrMoveFile(context.get(), src_path, dest_path, is_copy)); context.reset(NewContext(NULL)); context->set_allowed_bytes_growth( - ObfuscatedFileUtil::ComputeFilePathCost(dest_path) - - ObfuscatedFileUtil::ComputeFilePathCost(src_path)); + ObfuscatedFileUtil::ComputeFilePathCost(dest_path.internal_path()) - + ObfuscatedFileUtil::ComputeFilePathCost(src_path.internal_path())); EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CopyOrMoveFile(context.get(), src_path, dest_path, is_copy)); @@ -1097,7 +1110,7 @@ TEST_F(ObfuscatedFileUtilTest, TestMovePathQuotasWithRename) { } TEST_F(ObfuscatedFileUtilTest, TestMovePathQuotasWithoutRename) { - FilePath src_path = FilePath::FromUTF8Unsafe("src path"); + FileSystemPath src_path = CreatePathFromUTF8("src path"); scoped_ptr context(NewContext(NULL)); bool created = false; ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->EnsureFileExists( @@ -1105,12 +1118,12 @@ TEST_F(ObfuscatedFileUtilTest, TestMovePathQuotasWithoutRename) { bool exclusive = true; bool recursive = false; - FilePath dir_path = FilePath::FromUTF8Unsafe("directory path"); + FileSystemPath dir_path = CreatePathFromUTF8("directory path"); context.reset(NewContext(NULL)); ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory( context.get(), dir_path, exclusive, recursive)); - FilePath dest_path = dir_path.Append(src_path); + FileSystemPath dest_path = dir_path.Append(src_path.internal_path()); bool is_copy = false; int64 allowed_bytes_growth = -1000; // Over quota, this should still work. @@ -1131,7 +1144,7 @@ TEST_F(ObfuscatedFileUtilTest, TestMovePathQuotasWithoutRename) { ofu()->CopyOrMoveFile(context.get(), src_path, dest_path, is_copy)); EXPECT_EQ( allowed_bytes_growth + - ObfuscatedFileUtil::ComputeFilePathCost(src_path), + ObfuscatedFileUtil::ComputeFilePathCost(src_path.internal_path()), context->allowed_bytes_growth()); } @@ -1142,7 +1155,7 @@ TEST_F(ObfuscatedFileUtilTest, TestCopyInForeignFile) { TEST_F(ObfuscatedFileUtilTest, TestEnumerator) { scoped_ptr context(NewContext(NULL)); - FilePath src_path = FilePath::FromUTF8Unsafe("source dir"); + FileSystemPath src_path = CreatePathFromUTF8("source dir"); bool exclusive = true; bool recursive = false; ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory( @@ -1152,7 +1165,7 @@ TEST_F(ObfuscatedFileUtilTest, TestEnumerator) { std::set directories; FillTestDirectory(src_path, &files, &directories); - FilePath dest_path = FilePath::FromUTF8Unsafe("destination dir"); + FileSystemPath dest_path = CreatePathFromUTF8("destination dir"); context.reset(NewContext(NULL)); EXPECT_FALSE(ofu()->DirectoryExists(context.get(), dest_path)); @@ -1196,7 +1209,7 @@ TEST_F(ObfuscatedFileUtilTest, TestMigration) { FilePath data_path; SCOPED_TRACE(testing::Message() << "Path is " << test_case.path); EXPECT_EQ(base::PLATFORM_FILE_OK, - ofu()->GetFileInfo(context.get(), FilePath(test_case.path), + ofu()->GetFileInfo(context.get(), CreatePath(FilePath(test_case.path)), &ofu_file_info, &data_path)); if (test_case.is_directory) { EXPECT_TRUE(ofu_file_info.is_directory); @@ -1243,24 +1256,24 @@ TEST_F(ObfuscatedFileUtilTest, TestOriginEnumerator) { scoped_ptr helper( NewHelper(origin_url, kFileSystemTypeTemporary)); scoped_ptr context(NewContext(helper.get())); - context->set_src_origin_url(origin_url); - context->set_src_type(kFileSystemTypeTemporary); bool created = false; ASSERT_EQ(base::PLATFORM_FILE_OK, - ofu()->EnsureFileExists(context.get(), - FilePath::FromUTF8Unsafe("file"), &created)); + ofu()->EnsureFileExists( + context.get(), + helper->CreatePathFromUTF8("file"), + &created)); EXPECT_TRUE(created); } if (record.has_persistent) { scoped_ptr helper( NewHelper(origin_url, kFileSystemTypePersistent)); scoped_ptr context(NewContext(helper.get())); - context->set_src_origin_url(origin_url); - context->set_src_type(kFileSystemTypePersistent); bool created = false; ASSERT_EQ(base::PLATFORM_FILE_OK, - ofu()->EnsureFileExists(context.get(), - FilePath::FromUTF8Unsafe("file"), &created)); + ofu()->EnsureFileExists( + context.get(), + helper->CreatePathFromUTF8("file"), + &created)); EXPECT_TRUE(created); } } @@ -1310,21 +1323,24 @@ TEST_F(ObfuscatedFileUtilTest, TestRevokeUsageCache) { for (size_t i = 0; i < test::kRegularTestCaseSize; ++i) { SCOPED_TRACE(testing::Message() << "Creating kMigrationTestPath " << i); const test::TestCaseRecord& test_case = test::kRegularTestCases[i]; - FilePath path(test_case.path); - expected_quota += ObfuscatedFileUtil::ComputeFilePathCost(path); + FilePath file_path(test_case.path); + expected_quota += ObfuscatedFileUtil::ComputeFilePathCost(file_path); if (test_case.is_directory) { bool exclusive = true; bool recursive = false; ASSERT_EQ(base::PLATFORM_FILE_OK, - ofu()->CreateDirectory(context.get(), path, exclusive, recursive)); + ofu()->CreateDirectory(context.get(), CreatePath(file_path), + exclusive, recursive)); } else { bool created = false; ASSERT_EQ(base::PLATFORM_FILE_OK, - ofu()->EnsureFileExists(context.get(), path, &created)); + ofu()->EnsureFileExists(context.get(), CreatePath(file_path), + &created)); ASSERT_TRUE(created); ASSERT_EQ(base::PLATFORM_FILE_OK, - ofu()->Truncate(context.get(), path, - test_case.data_file_size)); + ofu()->Truncate(context.get(), + CreatePath(file_path), + test_case.data_file_size)); expected_quota += test_case.data_file_size; } } @@ -1337,8 +1353,8 @@ TEST_F(ObfuscatedFileUtilTest, TestRevokeUsageCache) { } TEST_F(ObfuscatedFileUtilTest, TestInconsistency) { - const FilePath kPath1 = FilePath::FromUTF8Unsafe("hoge"); - const FilePath kPath2 = FilePath::FromUTF8Unsafe("fuga"); + const FileSystemPath kPath1 = CreatePathFromUTF8("hoge"); + const FileSystemPath kPath2 = CreatePathFromUTF8("fuga"); scoped_ptr context; base::PlatformFile file; @@ -1398,7 +1414,7 @@ TEST_F(ObfuscatedFileUtilTest, TestInconsistency) { context.reset(NewContext(NULL)); EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CopyOrMoveFile(context.get(), kPath1, kPath2, - true /* copy */)); + true /* copy */)); ofu()->DestroyDirectoryDatabase(origin(), type()); context.reset(NewContext(NULL)); @@ -1414,11 +1430,12 @@ TEST_F(ObfuscatedFileUtilTest, TestInconsistency) { } TEST_F(ObfuscatedFileUtilTest, TestIncompleteDirectoryReading) { - const FilePath kPath[] = { - FilePath::FromUTF8Unsafe("foo"), - FilePath::FromUTF8Unsafe("bar"), - FilePath::FromUTF8Unsafe("baz") + const FileSystemPath kPath[] = { + CreatePathFromUTF8("foo"), + CreatePathFromUTF8("bar"), + CreatePathFromUTF8("baz") }; + const FileSystemPath empty_path = CreatePath(FilePath()); scoped_ptr context; for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kPath); ++i) { @@ -1432,7 +1449,7 @@ TEST_F(ObfuscatedFileUtilTest, TestIncompleteDirectoryReading) { context.reset(NewContext(NULL)); std::vector entries; EXPECT_EQ(base::PLATFORM_FILE_OK, - ofu()->ReadDirectory(context.get(), FilePath(), &entries)); + ofu()->ReadDirectory(context.get(), empty_path, &entries)); EXPECT_EQ(3u, entries.size()); context.reset(NewContext(NULL)); @@ -1444,20 +1461,20 @@ TEST_F(ObfuscatedFileUtilTest, TestIncompleteDirectoryReading) { context.reset(NewContext(NULL)); entries.clear(); EXPECT_EQ(base::PLATFORM_FILE_OK, - ofu()->ReadDirectory(context.get(), FilePath(), &entries)); + ofu()->ReadDirectory(context.get(), empty_path, &entries)); EXPECT_EQ(ARRAYSIZE_UNSAFE(kPath) - 1, entries.size()); } TEST_F(ObfuscatedFileUtilTest, TestDirectoryTimestampForCreation) { scoped_ptr context(NewContext(NULL)); - const FilePath dir_path(FILE_PATH_LITERAL("foo_dir")); + const FileSystemPath dir_path = CreatePathFromUTF8("foo_dir"); // Create working directory. EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(context.get(), dir_path, false, false)); // EnsureFileExists, create case. - FilePath path(dir_path.AppendASCII("EnsureFileExists_file")); + FileSystemPath path(dir_path.AppendASCII("EnsureFileExists_file")); bool created = false; ClearTimestamp(dir_path); context.reset(NewContext(NULL)); @@ -1533,7 +1550,7 @@ TEST_F(ObfuscatedFileUtilTest, TestDirectoryTimestampForCreation) { // CreateDirectory, create case. // Creating CreateDirectory_dir and CreateDirectory_dir/subdir. path = dir_path.AppendASCII("CreateDirectory_dir"); - FilePath subdir_path(path.AppendASCII("subdir")); + FileSystemPath subdir_path(path.AppendASCII("subdir")); ClearTimestamp(dir_path); context.reset(NewContext(NULL)); EXPECT_EQ(base::PLATFORM_FILE_OK, @@ -1564,7 +1581,7 @@ TEST_F(ObfuscatedFileUtilTest, TestDirectoryTimestampForCreation) { // CopyInForeignFile, create case. path = dir_path.AppendASCII("CopyInForeignFile_file"); - FilePath src_path = dir_path.AppendASCII("CopyInForeignFile_src_file"); + FileSystemPath src_path = dir_path.AppendASCII("CopyInForeignFile_src_file"); context.reset(NewContext(NULL)); EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->EnsureFileExists(context.get(), src_path, &created)); @@ -1577,20 +1594,22 @@ TEST_F(ObfuscatedFileUtilTest, TestDirectoryTimestampForCreation) { ClearTimestamp(dir_path); context.reset(NewContext(NULL)); EXPECT_EQ(base::PLATFORM_FILE_OK, - ofu()->CopyInForeignFile(context.get(), src_local_path, path)); + ofu()->CopyInForeignFile(context.get(), + CreatePath(src_local_path), + path)); EXPECT_NE(base::Time(), GetModifiedTime(dir_path)); } TEST_F(ObfuscatedFileUtilTest, TestDirectoryTimestampForDeletion) { scoped_ptr context(NewContext(NULL)); - const FilePath dir_path(FILE_PATH_LITERAL("foo_dir")); + const FileSystemPath dir_path = CreatePathFromUTF8("foo_dir"); // Create working directory. EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(context.get(), dir_path, false, false)); // DeleteFile, delete case. - FilePath path = dir_path.AppendASCII("DeleteFile_file"); + FileSystemPath path = dir_path.AppendASCII("DeleteFile_file"); bool created = false; context.reset(NewContext(NULL)); EXPECT_EQ(base::PLATFORM_FILE_OK, @@ -1612,7 +1631,7 @@ TEST_F(ObfuscatedFileUtilTest, TestDirectoryTimestampForDeletion) { // DeleteSingleDirectory, fail case. path = dir_path.AppendASCII("DeleteSingleDirectory_dir"); - FilePath file_path(path.AppendASCII("pakeratta")); + FileSystemPath file_path(path.AppendASCII("pakeratta")); context.reset(NewContext(NULL)); EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(context.get(), path, true, true)); @@ -1642,11 +1661,11 @@ TEST_F(ObfuscatedFileUtilTest, TestDirectoryTimestampForDeletion) { TEST_F(ObfuscatedFileUtilTest, TestDirectoryTimestampForCopyAndMove) { TestDirectoryTimestampHelper( - FilePath(FILE_PATH_LITERAL("copy overwrite")), true, true); + CreatePathFromUTF8("copy overwrite"), true, true); TestDirectoryTimestampHelper( - FilePath(FILE_PATH_LITERAL("copy non-overwrite")), true, false); + CreatePathFromUTF8("copy non-overwrite"), true, false); TestDirectoryTimestampHelper( - FilePath(FILE_PATH_LITERAL("move overwrite")), false, true); + CreatePathFromUTF8("move overwrite"), false, true); TestDirectoryTimestampHelper( - FilePath(FILE_PATH_LITERAL("move non-overwrite")), false, false); + CreatePathFromUTF8("move non-overwrite"), false, false); } diff --git a/webkit/fileapi/quota_file_util.cc b/webkit/fileapi/quota_file_util.cc index 7593b63..ed973b3e 100644 --- a/webkit/fileapi/quota_file_util.cc +++ b/webkit/fileapi/quota_file_util.cc @@ -22,6 +22,8 @@ namespace { // Checks if copying in the same filesystem can be performed. // This method is not called for moving within a single filesystem. +// Note: this method assumes the underlying file system uses platform +// file paths. bool CanCopy( const FilePath& src_file_path, const FilePath& dest_file_path, @@ -46,7 +48,7 @@ bool CanCopy( } void NotifyUpdate(FileSystemOperationContext* operation_context, - const GURL& origin_url, + const GURL& origin, FileSystemType type, int64 growth) { DCHECK(operation_context); @@ -62,7 +64,7 @@ void NotifyUpdate(FileSystemOperationContext* operation_context, operation_context->allowed_bytes_growth() - growth); if (quota_util) quota_util->UpdateOriginUsageOnFileThread( - quota_manager_proxy, origin_url, type, growth); + quota_manager_proxy, origin, type, growth); } } // namespace (anonymous) @@ -81,13 +83,13 @@ QuotaFileUtil* QuotaFileUtil::CreateDefault() { base::PlatformFileError QuotaFileUtil::Truncate( FileSystemOperationContext* fs_context, - const FilePath& path, + const FileSystemPath& path, int64 length) { int64 allowed_bytes_growth = fs_context->allowed_bytes_growth(); int64 growth = 0; base::PlatformFileInfo file_info; - if (!file_util::GetFileInfo(path, &file_info)) + if (!file_util::GetFileInfo(path.internal_path(), &file_info)) return base::PLATFORM_FILE_ERROR_FAILED; growth = length - file_info.size; @@ -99,9 +101,7 @@ base::PlatformFileError QuotaFileUtil::Truncate( fs_context, path, length); if (error == base::PLATFORM_FILE_OK) - NotifyUpdate(fs_context, - fs_context->src_origin_url(), - fs_context->src_type(), + NotifyUpdate(fs_context, path.origin(), path.type(), growth); return error; @@ -109,8 +109,8 @@ base::PlatformFileError QuotaFileUtil::Truncate( base::PlatformFileError QuotaFileUtil::CopyOrMoveFile( FileSystemOperationContext* fs_context, - const FilePath& src_file_path, - const FilePath& dest_file_path, + const FileSystemPath& src_path, + const FileSystemPath& dest_path, bool copy) { DCHECK(fs_context); @@ -121,25 +121,23 @@ base::PlatformFileError QuotaFileUtil::CopyOrMoveFile( if (copy) { int64 allowed_bytes_growth = fs_context->allowed_bytes_growth(); // The third argument (growth) is not used for now. - if (!CanCopy(src_file_path, dest_file_path, allowed_bytes_growth, &growth)) + if (!CanCopy(src_path.internal_path(), dest_path.internal_path(), + allowed_bytes_growth, &growth)) return base::PLATFORM_FILE_ERROR_NO_SPACE; } else { base::PlatformFileInfo dest_file_info; - if (!file_util::GetFileInfo(dest_file_path, &dest_file_info)) + if (!file_util::GetFileInfo(dest_path.internal_path(), &dest_file_info)) dest_file_info.size = 0; growth = -dest_file_info.size; } base::PlatformFileError error = underlying_file_util()->CopyOrMoveFile( - fs_context, src_file_path, dest_file_path, copy); + fs_context, src_path, dest_path, copy); if (error == base::PLATFORM_FILE_OK) { // TODO(kinuko): For cross-filesystem move case, call this with -growth // for source and growth for dest. - NotifyUpdate(fs_context, - fs_context->dest_origin_url(), - fs_context->dest_type(), - growth); + NotifyUpdate(fs_context, dest_path.origin(), dest_path.type(), growth); } return error; @@ -147,23 +145,20 @@ base::PlatformFileError QuotaFileUtil::CopyOrMoveFile( base::PlatformFileError QuotaFileUtil::DeleteFile( FileSystemOperationContext* fs_context, - const FilePath& file_path) { + const FileSystemPath& path) { DCHECK(fs_context); int64 growth = 0; base::PlatformFileInfo file_info; - if (!file_util::GetFileInfo(file_path, &file_info)) + if (!file_util::GetFileInfo(path.internal_path(), &file_info)) file_info.size = 0; growth = -file_info.size; base::PlatformFileError error = underlying_file_util()->DeleteFile( - fs_context, file_path); + fs_context, path); if (error == base::PLATFORM_FILE_OK) - NotifyUpdate(fs_context, - fs_context->src_origin_url(), - fs_context->src_type(), - growth); + NotifyUpdate(fs_context, path.origin(), path.type(), growth); return error; } diff --git a/webkit/fileapi/quota_file_util.h b/webkit/fileapi/quota_file_util.h index 25be5f3..cf8e069 100644 --- a/webkit/fileapi/quota_file_util.h +++ b/webkit/fileapi/quota_file_util.h @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 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. @@ -31,16 +31,16 @@ class QuotaFileUtil : public FileSystemFileUtil { virtual base::PlatformFileError Truncate( FileSystemOperationContext* fs_context, - const FilePath& path, + const FileSystemPath& path, int64 length) OVERRIDE; virtual base::PlatformFileError CopyOrMoveFile( FileSystemOperationContext* fs_context, - const FilePath& src_file_path, - const FilePath& dest_file_path, + const FileSystemPath& src_path, + const FileSystemPath& dest_path, bool copy) OVERRIDE; virtual base::PlatformFileError DeleteFile( FileSystemOperationContext* fs_context, - const FilePath& file_path) OVERRIDE; + const FileSystemPath& path) OVERRIDE; private: DISALLOW_COPY_AND_ASSIGN(QuotaFileUtil); diff --git a/webkit/fileapi/quota_file_util_unittest.cc b/webkit/fileapi/quota_file_util_unittest.cc index 8790352..da29ba1 100644 --- a/webkit/fileapi/quota_file_util_unittest.cc +++ b/webkit/fileapi/quota_file_util_unittest.cc @@ -38,8 +38,8 @@ class QuotaFileUtilTest : public testing::Test { return quota_test_helper_.NewOperationContext(); } - FilePath Path(const std::string& file_name) { - return base_dir_.AppendASCII(file_name); + FileSystemPath Path(const std::string& file_name) { + return quota_test_helper_.CreatePath(base_dir_.AppendASCII(file_name)); } base::PlatformFileError CreateFile(const char* file_name, diff --git a/webkit/fileapi/sandbox_mount_point_provider.cc b/webkit/fileapi/sandbox_mount_point_provider.cc index cbcda1d..a659615 100644 --- a/webkit/fileapi/sandbox_mount_point_provider.cc +++ b/webkit/fileapi/sandbox_mount_point_provider.cc @@ -520,11 +520,10 @@ int64 SandboxMountPointProvider::GetOriginUsageOnFileThread( // Get the directory size now and update the cache. FileSystemUsageCache::Delete(usage_file_path); - FileSystemOperationContext context(NULL, sandbox_file_util_); - context.set_src_origin_url(origin_url); - context.set_src_type(type); + FileSystemOperationContext context(NULL); + FileSystemPath path(origin_url, type, FilePath(), sandbox_file_util_); scoped_ptr enumerator( - sandbox_file_util_->CreateFileEnumerator(&context, FilePath())); + sandbox_file_util_->CreateFileEnumerator(&context, path)); FilePath file_path_each; int64 usage = 0; diff --git a/webkit/fileapi/sandbox_mount_point_provider_unittest.cc b/webkit/fileapi/sandbox_mount_point_provider_unittest.cc index 2f07dc5..7dd6355 100644 --- a/webkit/fileapi/sandbox_mount_point_provider_unittest.cc +++ b/webkit/fileapi/sandbox_mount_point_provider_unittest.cc @@ -196,13 +196,8 @@ class SandboxMountPointProviderMigrationTest : public testing::Test { root.AppendASCII(seed).AppendASCII("d 0").AppendASCII("file 2")); } - FileSystemOperationContext* NewContext(const GURL& origin_url, - fileapi::FileSystemType type) { - FileSystemOperationContext* context = new FileSystemOperationContext( - file_system_context_, file_util()); - context->set_src_origin_url(origin_url); - context->set_src_type(type); - return context; + FileSystemOperationContext* NewContext() { + return new FileSystemOperationContext(file_system_context_); } std::string URLAndTypeToSeedString(const GURL& origin_url, @@ -215,37 +210,40 @@ class SandboxMountPointProviderMigrationTest : public testing::Test { const GURL& origin_url, fileapi::FileSystemType type) { scoped_ptr context; - FilePath seed = FilePath().AppendASCII( + FilePath seed_file_path = FilePath().AppendASCII( URLAndTypeToSeedString(origin_url, type)); - context.reset(NewContext(origin_url, type)); + FileSystemPath root(origin_url, type, FilePath(), file_util()); + FileSystemPath seed = root.Append(seed_file_path); + + context.reset(NewContext()); EXPECT_TRUE(file_util()->DirectoryExists( context.get(), seed)); - context.reset(NewContext(origin_url, type)); + context.reset(NewContext()); EXPECT_TRUE(file_util()->DirectoryExists( - context.get(), seed.Append(seed))); - context.reset(NewContext(origin_url, type)); + context.get(), seed.Append(seed_file_path))); + context.reset(NewContext()); EXPECT_TRUE(file_util()->DirectoryExists( context.get(), seed.AppendASCII("d 0"))); - context.reset(NewContext(origin_url, type)); + context.reset(NewContext()); EXPECT_TRUE(file_util()->DirectoryExists( context.get(), seed.AppendASCII("d 1"))); - context.reset(NewContext(origin_url, type)); + context.reset(NewContext()); EXPECT_TRUE(file_util()->PathExists( - context.get(), FilePath().AppendASCII("file 0"))); - context.reset(NewContext(origin_url, type)); + context.get(), root.AppendASCII("file 0"))); + context.reset(NewContext()); EXPECT_FALSE(file_util()->DirectoryExists( context.get(), seed.AppendASCII("file 0"))); - context.reset(NewContext(origin_url, type)); + context.reset(NewContext()); EXPECT_TRUE(file_util()->PathExists( context.get(), seed.AppendASCII("d 0").AppendASCII("file 1"))); - context.reset(NewContext(origin_url, type)); + context.reset(NewContext()); EXPECT_FALSE(file_util()->DirectoryExists( context.get(), seed.AppendASCII("d 0").AppendASCII("file 1"))); - context.reset(NewContext(origin_url, type)); + context.reset(NewContext()); EXPECT_TRUE(file_util()->PathExists( context.get(), seed.AppendASCII("d 0").AppendASCII("file 2"))); - context.reset(NewContext(origin_url, type)); + context.reset(NewContext()); EXPECT_FALSE(file_util()->DirectoryExists( context.get(), seed.AppendASCII("d 0").AppendASCII("file 2"))); } @@ -308,27 +306,26 @@ class SandboxMountPointProviderMigrationTest : public testing::Test { type, host, &origins); break; case 6: - sandbox_provider()->GetOriginUsageOnFileThread( - origin_url, type); + sandbox_provider()->GetOriginUsageOnFileThread(origin_url, type); break; case 7: // This case has to use an origin that already exists in the // migrated data. sandbox_provider()->UpdateOriginUsageOnFileThread( NULL, kMigrationTestRecords[0].origin, - fileapi::kFileSystemTypeTemporary, delta); + kFileSystemTypeTemporary, delta); break; case 8: // This case has to use a filesystem that already exists in the // migrated data. sandbox_provider()->StartUpdateOriginOnFileThread( - kMigrationTestRecords[0].origin, fileapi::kFileSystemTypeTemporary); + kMigrationTestRecords[0].origin, kFileSystemTypeTemporary); break; case 9: // This case has to use a filesystem that already exists in the // migrated data. sandbox_provider()->EndUpdateOriginOnFileThread( - kMigrationTestRecords[0].origin, fileapi::kFileSystemTypeTemporary); + kMigrationTestRecords[0].origin, kFileSystemTypeTemporary); break; default: FAIL(); diff --git a/webkit/fileapi/webkit_fileapi.gypi b/webkit/fileapi/webkit_fileapi.gypi index 9e7f815..02781d4 100644 --- a/webkit/fileapi/webkit_fileapi.gypi +++ b/webkit/fileapi/webkit_fileapi.gypi @@ -37,6 +37,8 @@ 'file_system_options.h', 'file_system_origin_database.cc', 'file_system_origin_database.h', + 'file_system_path.cc', + 'file_system_path.h', 'file_system_quota_client.cc', 'file_system_quota_client.h', 'file_system_quota_util.cc', -- cgit v1.1