Bind: Merge FileUtilProxy and FileSystemFileUtilProxy: Delete/Touch/Truncate/Copy/Move

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/bind.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/escape.h"
@@ skipping 60 matching lines @@
 }
 
 FileSystemOperation::~FileSystemOperation() {
   if (file_writer_delegate_.get())
     base::FileUtilProxy::RelayClose(
         proxy_,
         base::Bind(&FileSystemFileUtil::Close,
                    base::Unretained(operation_context_.src_file_util()),
                    base::Unretained(&operation_context_)),
         file_writer_delegate_->file(),
-        FileSystemFileUtilProxy::StatusCallback());
+        base::FileUtilProxy::StatusCallback());
 }
 
 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
 
@@ skipping 15 matching lines @@
 void FileSystemOperation::CreateFile(const GURL& path,
                                      bool exclusive) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationCreateFile;
 #endif
   if (!SetupSrcContextForWrite(path, true)) {
     delete this;
     return;
   }
-  exclusive_ = exclusive;
-
   GetUsageAndQuotaThenCallback(
       operation_context_.src_origin_url(),
       base::Bind(&FileSystemOperation::DelayedCreateFileForQuota,
-                 weak_factory_.GetWeakPtr()));
+                 weak_factory_.GetWeakPtr(), exclusive));
 }
 
 void FileSystemOperation::DelayedCreateFileForQuota(
+    bool exclusive,
     quota::QuotaStatusCode status, int64 usage, int64 quota) {
   operation_context_.set_allowed_bytes_growth(quota - usage);
 
   quota_util_helper_.reset(new ScopedQuotaUtilHelper(
       file_system_context(),
       operation_context_.src_origin_url(),
       operation_context_.src_type()));
 
   FileSystemFileUtilProxy::EnsureFileExists(
       operation_context_,
       proxy_,
       src_virtual_path_,
       base::Bind(
-          exclusive_ ? &FileSystemOperation::DidEnsureFileExistsExclusive
-                     : &FileSystemOperation::DidEnsureFileExistsNonExclusive,
+          exclusive ? &FileSystemOperation::DidEnsureFileExistsExclusive
+                    : &FileSystemOperation::DidEnsureFileExistsNonExclusive,
           weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemOperation::CreateDirectory(const GURL& path,
                                           bool exclusive,
                                           bool recursive) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationCreateDirectory;
 #endif
   if (!SetupSrcContextForWrite(path, true)) {
     delete this;
     return;
   }
-  exclusive_ = exclusive;
-  recursive_ = recursive;
-
   GetUsageAndQuotaThenCallback(
       operation_context_.src_origin_url(),
       base::Bind(&FileSystemOperation::DelayedCreateDirectoryForQuota,
-                 weak_factory_.GetWeakPtr()));
+                 weak_factory_.GetWeakPtr(), exclusive, recursive));
 }
 
 void FileSystemOperation::DelayedCreateDirectoryForQuota(
+    bool exclusive, bool recursive,
     quota::QuotaStatusCode status, int64 usage, int64 quota) {
   operation_context_.set_allowed_bytes_growth(quota - usage);
 
   quota_util_helper_.reset(new ScopedQuotaUtilHelper(
       file_system_context(),
       operation_context_.src_origin_url(),
       operation_context_.src_type()));
 
-  FileSystemFileUtilProxy::CreateDirectory(
-      operation_context_, proxy_, src_virtual_path_, exclusive_,
-      recursive_,
+  base::FileUtilProxy::RelayFileTask(
+      proxy_, FROM_HERE,
+      base::Bind(&FileSystemFileUtil::CreateDirectory,
+                 base::Unretained(operation_context_.src_file_util()),
+                 base::Unretained(&operation_context_),

[willchan no longer on Chromium, 2011/11/01 23:56:48]

Sorry, I'm not familiar with the code. It's not obvious to me that this is
correct. What prevents operation_context_ from going away? I think this
FileSystemOperation is supposed to be self-deleting, right? That said, I don't
know when it gets deleted, and it looks like
FileSystemOperation::DidFinishOperation() uses a weak pointer, so that makes me
a bit worried. Is base::Unretained() correct here? Is there someone else who can
look at this to doublecheck? Adam Klein perhaps?

[kinuko, 2011/11/02 08:04:28]

Right, it's self-deleting and WeakPtr makes things confusing.  I converted some
'delete this' with base::Owned(this) and removed WeakPtr usage.  Verified that
valgrind says ok in my local env.  Hoping that Eric, Taiju or Adam can
doublecheck the changes under fileapi.

+                 src_virtual_path_, exclusive, recursive),
       base::Bind(&FileSystemOperation::DidFinishFileOperation,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemOperation::Copy(const GURL& src_path,
                                const GURL& dest_path) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationCopy;
 #endif
@@ skipping 11 matching lines @@
 
 void FileSystemOperation::DelayedCopyForQuota(quota::QuotaStatusCode status,
                                               int64 usage, int64 quota) {
   operation_context_.set_allowed_bytes_growth(quota - usage);
 
   quota_util_helper_.reset(new ScopedQuotaUtilHelper(
       file_system_context(),
       operation_context_.dest_origin_url(),
       operation_context_.dest_type()));
 
-  FileSystemFileUtilProxy::Copy(
-      operation_context_, proxy_, src_virtual_path_,
-      dest_virtual_path_,
+  base::FileUtilProxy::RelayFileTask(
+      proxy_, FROM_HERE,
+      base::Bind(&FileSystemFileUtil::Copy,
+                 base::Unretained(operation_context_.src_file_util()),
+                 base::Unretained(&operation_context_),
+                 src_virtual_path_, dest_virtual_path_),
       base::Bind(&FileSystemOperation::DidFinishFileOperation,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemOperation::Move(const GURL& src_path,
                                const GURL& dest_path) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationMove;
 #endif
@@ skipping 11 matching lines @@
 
 void FileSystemOperation::DelayedMoveForQuota(quota::QuotaStatusCode status,
                                               int64 usage, int64 quota) {
   operation_context_.set_allowed_bytes_growth(quota - usage);
 
   quota_util_helper_.reset(new ScopedQuotaUtilHelper(
       file_system_context(),
       operation_context_.dest_origin_url(),
       operation_context_.dest_type()));
 
-  FileSystemFileUtilProxy::Move(
-      operation_context_, proxy_, src_virtual_path_,
-      dest_virtual_path_,
+  base::FileUtilProxy::RelayFileTask(
+      proxy_, FROM_HERE,
+      base::Bind(&FileSystemFileUtil::Move,
+                 base::Unretained(operation_context_.src_file_util()),
+                 base::Unretained(&operation_context_),
+                 src_virtual_path_, dest_virtual_path_),
       base::Bind(&FileSystemOperation::DidFinishFileOperation,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemOperation::DirectoryExists(const GURL& path) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationDirectoryExists;
 #endif
   if (!SetupSrcContextForRead(path)) {
@@ skipping 58 matching lines @@
 void FileSystemOperation::Remove(const GURL& path, bool recursive) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationRemove;
 #endif
   if (!SetupSrcContextForWrite(path, false)) {
     delete this;
     return;
   }
 
-  FileSystemFileUtilProxy::Delete(
-      operation_context_, proxy_, src_virtual_path_, recursive,
+  base::FileUtilProxy::RelayFileTask(
+      proxy_, FROM_HERE,
+      base::Bind(&FileSystemFileUtil::Delete,
+                 base::Unretained(operation_context_.src_file_util()),
+                 base::Unretained(&operation_context_),
+                 src_virtual_path_, recursive),
       base::Bind(&FileSystemOperation::DidFinishFileOperation,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemOperation::Write(
     scoped_refptr<net::URLRequestContext> url_request_context,
     const GURL& path,
     const GURL& blob_url,
     int64 offset) {
 #ifndef NDEBUG
@@ skipping 45 matching lines @@
 
 void FileSystemOperation::Truncate(const GURL& path, int64 length) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationTruncate;
 #endif
   if (!SetupSrcContextForWrite(path, false)) {
     delete this;
     return;
   }
-  length_ = length;
-
   GetUsageAndQuotaThenCallback(
       operation_context_.src_origin_url(),
       base::Bind(&FileSystemOperation::DelayedTruncateForQuota,
-                 weak_factory_.GetWeakPtr()));
+                 weak_factory_.GetWeakPtr(), length));
 }
 
-void FileSystemOperation::DelayedTruncateForQuota(quota::QuotaStatusCode status,
+void FileSystemOperation::DelayedTruncateForQuota(int64 length,
+                                                  quota::QuotaStatusCode status,
                                                   int64 usage, int64 quota) {
   operation_context_.set_allowed_bytes_growth(quota - usage);
 
   quota_util_helper_.reset(new ScopedQuotaUtilHelper(
       file_system_context(),
       operation_context_.src_origin_url(),
       operation_context_.src_type()));
 
-  FileSystemFileUtilProxy::Truncate(
-      operation_context_, proxy_, src_virtual_path_, length_,
+  base::FileUtilProxy::RelayFileTask(
+      proxy_, FROM_HERE,
+      base::Bind(&FileSystemFileUtil::Truncate,
+                 base::Unretained(operation_context_.src_file_util()),
+                 base::Unretained(&operation_context_),
+                 src_virtual_path_, length),
       base::Bind(&FileSystemOperation::DidFinishFileOperation,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemOperation::TouchFile(const GURL& path,
                                     const base::Time& last_access_time,
                                     const base::Time& last_modified_time) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationTouchFile;
 #endif
   if (!SetupSrcContextForWrite(path, true)) {
     delete this;
     return;
   }
 
-  FileSystemFileUtilProxy::Touch(
-      operation_context_, proxy_, src_virtual_path_,
-      last_access_time, last_modified_time,
+  base::FileUtilProxy::RelayFileTask(
+      proxy_, FROM_HERE,
+      base::Bind(&FileSystemFileUtil::Touch,
+                 base::Unretained(operation_context_.src_file_util()),
+                 base::Unretained(&operation_context_),
+                 src_virtual_path_, last_access_time, last_modified_time),
       base::Bind(&FileSystemOperation::DidTouchFile,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemOperation::OpenFile(const GURL& path,
                                    int file_flags,
                                    base::ProcessHandle peer_handle) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationOpenFile;
@@ skipping 15 matching lines @@
     if (!SetupSrcContextForWrite(path, true)) {
       delete this;
       return;
     }
   } else {
     if (!SetupSrcContextForRead(path)) {
       delete this;
       return;
     }
   }
-  file_flags_ = file_flags;
-
   GetUsageAndQuotaThenCallback(
       operation_context_.src_origin_url(),
       base::Bind(&FileSystemOperation::DelayedOpenFileForQuota,
-                 weak_factory_.GetWeakPtr()));
+                 weak_factory_.GetWeakPtr(), file_flags));
 }
 
-void FileSystemOperation::DelayedOpenFileForQuota(quota::QuotaStatusCode status,
+void FileSystemOperation::DelayedOpenFileForQuota(int file_flags,
+                                                  quota::QuotaStatusCode status,
                                                   int64 usage, int64 quota) {
   operation_context_.set_allowed_bytes_growth(quota - usage);
 
   quota_util_helper_.reset(new ScopedQuotaUtilHelper(
       file_system_context(),
       operation_context_.src_origin_url(),
       operation_context_.src_type()));
 
   base::FileUtilProxy::RelayCreateOrOpen(
       proxy_,
       base::Bind(&FileSystemFileUtil::CreateOrOpen,
                  base::Unretained(operation_context_.src_file_util()),
                  base::Unretained(&operation_context_),
                  src_virtual_path_,
-                 file_flags_),
+                 file_flags),
       base::Bind(&FileSystemFileUtil::Close,
                  base::Unretained(operation_context_.src_file_util()),
                  base::Unretained(&operation_context_)),
       base::Bind(&FileSystemOperation::DidOpenFile,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemOperation::SyncGetPlatformPath(const GURL& path,
                                               FilePath* platform_path) {
 #ifndef NDEBUG
@@ skipping 351 matching lines @@
   bool 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;
 }
 
 }  // namespace fileapi