Add initial code to do filename munging in the FileSystem....

webkit/fileapi/file_system_operation.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "webkit/fileapi/file_system_operation.h"
 
 #include "base/time.h"
 #include "net/url_request/url_request_context.h"
 #include "webkit/fileapi/file_system_callback_dispatcher.h"
 #include "webkit/fileapi/file_system_context.h"
+#include "webkit/fileapi/file_system_file_util_proxy.h"
+#include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_quota_manager.h"
 #include "webkit/fileapi/file_writer_delegate.h"
 
 namespace fileapi {
 
 FileSystemOperation::FileSystemOperation(
     FileSystemCallbackDispatcher* dispatcher,
     scoped_refptr<base::MessageLoopProxy> proxy,
     FileSystemContext* file_system_context)
     : proxy_(proxy),
       dispatcher_(dispatcher),
       file_system_context_(file_system_context),
+      file_system_operation_context_(
+          new FileSystemOperationContext(file_system_context)),
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(dispatcher);
 #ifndef NDEBUG
   pending_operation_ = kOperationNone;
 #endif
 }
 
 FileSystemOperation::~FileSystemOperation() {
   if (file_writer_delegate_.get())
-    base::FileUtilProxy::Close(proxy_, file_writer_delegate_->file(), NULL);
+    FileSystemFileUtilProxy::Close(
+        file_system_operation_context_.get(),
+        proxy_, file_writer_delegate_->file(), NULL);

[Dai Mikurube (google.com), 2011/02/22 10:13:53]

It's to be fixed as follows :
base::FileUtilProxy::Close(
    _proxy, file_writer_delegate_->file(), NULL);

 }
 
 void FileSystemOperation::OpenFileSystem(
     const GURL& origin_url, fileapi::FileSystemType type, bool create) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = static_cast<FileSystemOperation::OperationType>(
       kOperationOpenFileSystem);
 #endif
 
   DCHECK(file_system_context_.get());
   file_system_context_->path_manager()->GetFileSystemRootPath(
       origin_url, type, create,
       callback_factory_.NewCallback(&FileSystemOperation::DidGetRootPath));
 }
 
 void FileSystemOperation::CreateFile(const FilePath& path,
                                      bool exclusive) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationCreateFile;
 #endif
 
   if (!VerifyFileSystemPathForWrite(path, true /* create */, 0)) {
     delete this;
     return;
   }
-  base::FileUtilProxy::EnsureFileExists(
-    proxy_, path, callback_factory_.NewCallback(
-        exclusive ? &FileSystemOperation::DidEnsureFileExistsExclusive
-                  : &FileSystemOperation::DidEnsureFileExistsNonExclusive));
+  FileSystemFileUtilProxy::EnsureFileExists(
+      file_system_operation_context_.get(),
+      proxy_, path, callback_factory_.NewCallback(
+          exclusive ? &FileSystemOperation::DidEnsureFileExistsExclusive
+                    : &FileSystemOperation::DidEnsureFileExistsNonExclusive));
 }
 
 void FileSystemOperation::CreateDirectory(const FilePath& path,
                                           bool exclusive,
-                                          bool recursive) {
+                                          bool unused) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationCreateDirectory;
 #endif
 
   if (!VerifyFileSystemPathForWrite(path, true /* create */, 0)) {
     delete this;
     return;
   }
-  base::FileUtilProxy::CreateDirectory(
-      proxy_, path, exclusive, recursive, callback_factory_.NewCallback(
+  FileSystemFileUtilProxy::CreateDirectory(
+      file_system_operation_context_.get(),
+      proxy_, path, exclusive, callback_factory_.NewCallback(
           &FileSystemOperation::DidFinishFileOperation));
 }
 
 void FileSystemOperation::Copy(const FilePath& src_path,
                                const FilePath& dest_path) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationCopy;
 #endif
 
   if (!VerifyFileSystemPathForRead(src_path) ||
       !VerifyFileSystemPathForWrite(dest_path, true /* create */,
                                     FileSystemQuotaManager::kUnknownSize)) {
     delete this;
     return;
   }
-  base::FileUtilProxy::Copy(proxy_, src_path, dest_path,
-      callback_factory_.NewCallback(
+  FileSystemFileUtilProxy::Copy(
+      file_system_operation_context_.get(),
+      proxy_, src_path, dest_path, callback_factory_.NewCallback(
           &FileSystemOperation::DidFinishFileOperation));
 }
 
 void FileSystemOperation::Move(const FilePath& src_path,
                                const FilePath& dest_path) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationMove;
 #endif
 
   if (!VerifyFileSystemPathForRead(src_path) ||
       !VerifyFileSystemPathForWrite(dest_path, true /* create */,
                                     FileSystemQuotaManager::kUnknownSize)) {
     delete this;
     return;
   }
-  base::FileUtilProxy::Move(proxy_, src_path, dest_path,
-      callback_factory_.NewCallback(
+  FileSystemFileUtilProxy::Move(
+      file_system_operation_context_.get(),
+      proxy_, src_path, dest_path, callback_factory_.NewCallback(
           &FileSystemOperation::DidFinishFileOperation));
 }
 
 void FileSystemOperation::DirectoryExists(const FilePath& path) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationDirectoryExists;
 #endif
 
   if (!VerifyFileSystemPathForRead(path)) {
     delete this;
     return;
   }
-  base::FileUtilProxy::GetFileInfo(proxy_, path, callback_factory_.NewCallback(
-      &FileSystemOperation::DidDirectoryExists));
+  FileSystemFileUtilProxy::GetFileInfo(
+      file_system_operation_context_.get(),
+      proxy_, path, callback_factory_.NewCallback(
+          &FileSystemOperation::DidDirectoryExists));
 }
 
 void FileSystemOperation::FileExists(const FilePath& path) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationFileExists;
 #endif
 
   if (!VerifyFileSystemPathForRead(path)) {
     delete this;
     return;
   }
-  base::FileUtilProxy::GetFileInfo(proxy_, path, callback_factory_.NewCallback(
-      &FileSystemOperation::DidFileExists));
+  FileSystemFileUtilProxy::GetFileInfo(
+      file_system_operation_context_.get(),
+      proxy_, path, callback_factory_.NewCallback(
+          &FileSystemOperation::DidFileExists));
 }
 
 void FileSystemOperation::GetMetadata(const FilePath& path) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationGetMetadata;
 #endif
 
   if (!VerifyFileSystemPathForRead(path)) {
     delete this;
     return;
   }
-  base::FileUtilProxy::GetFileInfo(proxy_, path, callback_factory_.NewCallback(
-      &FileSystemOperation::DidGetMetadata));
+  FileSystemFileUtilProxy::GetFileInfo(
+      file_system_operation_context_.get(),
+      proxy_, path, callback_factory_.NewCallback(
+          &FileSystemOperation::DidGetMetadata));
 }
 
 void FileSystemOperation::ReadDirectory(const FilePath& path) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationReadDirectory;
 #endif
 
   if (!VerifyFileSystemPathForRead(path)) {
     delete this;
     return;
   }
-  base::FileUtilProxy::ReadDirectory(proxy_, path,
-      callback_factory_.NewCallback(
+  FileSystemFileUtilProxy::ReadDirectory(
+      file_system_operation_context_.get(),
+      proxy_, path, callback_factory_.NewCallback(
           &FileSystemOperation::DidReadDirectory));
 }
 
 void FileSystemOperation::Remove(const FilePath& path, bool recursive) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationRemove;
 #endif
 
   if (!VerifyFileSystemPathForWrite(path, false /* create */, 0)) {
     delete this;
     return;
   }
-  base::FileUtilProxy::Delete(proxy_, path, recursive,
-      callback_factory_.NewCallback(
+  FileSystemFileUtilProxy::Delete(
+      file_system_operation_context_.get(),
+      proxy_, path, recursive, callback_factory_.NewCallback(
           &FileSystemOperation::DidFinishFileOperation));
 }
 
 void FileSystemOperation::Write(
     scoped_refptr<net::URLRequestContext> url_request_context,
     const FilePath& path,
     const GURL& blob_url,
     int64 offset) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationWrite;
 #endif
   if (!VerifyFileSystemPathForWrite(path, true /* create */,
                                     FileSystemQuotaManager::kUnknownSize)) {
     delete this;
     return;
   }
   DCHECK(blob_url.is_valid());
   file_writer_delegate_.reset(new FileWriterDelegate(this, offset));
   blob_request_.reset(
       new net::URLRequest(blob_url, file_writer_delegate_.get()));
   blob_request_->set_context(url_request_context);
-  base::FileUtilProxy::CreateOrOpen(
+  FileSystemFileUtilProxy::CreateOrOpen(
+      file_system_operation_context_.get(),
       proxy_,
       path,
       base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE |
           base::PLATFORM_FILE_ASYNC,
       callback_factory_.NewCallback(
           &FileSystemOperation::OnFileOpenedForWrite));
 }
 
 void FileSystemOperation::Truncate(const FilePath& path, int64 length) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationTruncate;
 #endif
   if (!VerifyFileSystemPathForWrite(path, false /* create */, 0)) {
     delete this;
     return;
   }
-  base::FileUtilProxy::Truncate(proxy_, path, length,
-      callback_factory_.NewCallback(
+  FileSystemFileUtilProxy::Truncate(
+      file_system_operation_context_.get(),
+      proxy_, path, length, callback_factory_.NewCallback(
           &FileSystemOperation::DidFinishFileOperation));
 }
 
 void FileSystemOperation::TouchFile(const FilePath& path,
                                     const base::Time& last_access_time,
                                     const base::Time& last_modified_time) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationTouchFile;
 #endif
 
   if (!VerifyFileSystemPathForWrite(path, true /* create */, 0)) {
     delete this;
     return;
   }
-  base::FileUtilProxy::Touch(
+  FileSystemFileUtilProxy::Touch(
+      file_system_operation_context_.get(),
       proxy_, path, last_access_time, last_modified_time,
       callback_factory_.NewCallback(&FileSystemOperation::DidTouchFile));
 }
 
 // We can only get here on a write or truncate that's not yet completed.
 // We don't support cancelling any other operation at this time.
 void FileSystemOperation::Cancel(FileSystemOperation* cancel_operation_ptr) {
   scoped_ptr<FileSystemOperation> cancel_operation(cancel_operation_ptr);
   if (file_writer_delegate_.get()) {
 #ifndef NDEBUG
@@ skipping 144 matching lines @@
 
 bool FileSystemOperation::VerifyFileSystemPathForRead(
     const FilePath& path) {
   // If we have no context, we just allow any operations.
   if (!file_system_context_.get())
     return true;
 
   // We may want do more checks, but for now it just checks if the given
   // |path| is under the valid FileSystem root path for this host context.
   if (!file_system_context_->path_manager()->CrackFileSystemPath(
-          path, NULL, NULL, NULL)) {
+          path, NULL, NULL, NULL, NULL)) {
     dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
     return false;
   }
   return true;
 }
 
 bool FileSystemOperation::VerifyFileSystemPathForWrite(
     const FilePath& path, bool create, int64 growth) {
   GURL origin_url;
   FilePath virtual_path;
 
   // If we have no context, we just allow any operations.
   if (!file_system_context_.get())
     return true;
 
   if (!file_system_context_->path_manager()->CrackFileSystemPath(
-          path, &origin_url, NULL, &virtual_path)) {
+          path, &origin_url, NULL, NULL, &virtual_path)) {
     dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
     return false;
   }
   // Any write access is disallowed on the root path.
   if (virtual_path.value().length() == 0 ||
       virtual_path.DirName().value() == virtual_path.value()) {
     dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
     return false;
   }
   if (create && file_system_context_->path_manager()->IsRestrictedFileName(
           path.BaseName())) {
     dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
     return false;
   }
   // TODO(kinuko): For operations with kUnknownSize we'll eventually
   // need to resolve what amount of size it's going to write.
   if (!file_system_context_->quota_manager()->CheckOriginQuota(
           origin_url, growth)) {
     dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_NO_SPACE);
     return false;
   }
   return true;
 }
 
 }  // namespace fileapi