Wired support for file truncating with RemoteFileSystemOperation::OpenFile() method (case when base…

chrome/browser/chromeos/gdata/gdata_file_system_proxy.cc

 // 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 "chrome/browser/chromeos/gdata/gdata_file_system_proxy.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 14 matching lines @@
 using fileapi::FileSystemOperationInterface;
 using webkit_blob::ShareableFileReference;
 
 namespace {
 
 const char kGDataRootDirectory[] = "drive";
 const char kFeedField[] = "feed";
 
 
 // Helper function that creates platform file on bocking IO thread pool.
-void CreatePlatformFileOnIOPool(const FilePath& local_path,
+void OpenPlatformFileOnIOPool(const FilePath& local_path,
                                 int file_flags,
                                 base::PlatformFile* platform_file,
                                 base::PlatformFileError* open_error) {
   bool created;
   *platform_file = base::CreatePlatformFile(local_path,
                                             file_flags,
                                             &created,
                                             open_error);
 }
 
-// Helper function to run reply on results of CreatePlatformFileOnIOPool() on
+// Helper function to run reply on results of OpenPlatformFileOnIOPool() on
 // IO thread.
-void OnPlatformFileCreated(
+void OnPlatformFileOpened(
     const FileSystemOperationInterface::OpenFileCallback& callback,
     base::ProcessHandle peer_handle,
     base::PlatformFile* platform_file,
     base::PlatformFileError* open_error) {
   callback.Run(*open_error, *platform_file, peer_handle);
 }
 
 // Helper function to run OpenFileCallback from
 // GDataFileSystemProxy::OpenFile().
 void OnGetFileByPathForOpen(
     const FileSystemOperationInterface::OpenFileCallback& callback,
     int file_flags,
     base::ProcessHandle peer_handle,
     base::PlatformFileError error,
     const FilePath& local_path,
     const std::string& unused_mime_type,
     gdata::GDataFileType file_type) {
   if (error != base::PLATFORM_FILE_OK) {
     callback.Run(error, base::kInvalidPlatformFileValue, peer_handle);
     return;
   }
 
   base::PlatformFile* platform_file = new base::PlatformFile(
       base::kInvalidPlatformFileValue);
   base::PlatformFileError* open_error =
       new base::PlatformFileError(base::PLATFORM_FILE_ERROR_FAILED);
   BrowserThread::GetBlockingPool()->PostTaskAndReply(FROM_HERE,
-      base::Bind(&CreatePlatformFileOnIOPool,
+      base::Bind(&OpenPlatformFileOnIOPool,
                  local_path,
                  file_flags,
                  platform_file,
                  open_error),
-      base::Bind(&OnPlatformFileCreated,
+      base::Bind(&OnPlatformFileOpened,
                  callback,
                  peer_handle,
                  base::Owned(platform_file),
                  base::Owned(open_error)));
 
 }
 
 // Helper function to run SnapshotFileCallback from
 // GDataFileSystemProxy::CreateSnapshotFile().
 void CallSnapshotFileCallback(
@@ skipping 23 matching lines @@
   base::PlatformFileInfo final_file_info(file_info);
   final_file_info.last_modified = base::Time();
 
   callback.Run(error, final_file_info, local_path, file_ref);
 }
 
 void OnClose(const FilePath& local_path, base::PlatformFileError error_code) {
   DVLOG(1) << "Closed: " << local_path.AsUTF8Unsafe() << ": " << error_code;
 }
 
+void OpenAndTruncateOnIOPool(

[kinaba, 2012/06/27 09:17:21]

I think we can simply use OpenPlatformFileOnIOPool() also for truncation case.
Passing base::PLATFORM_FILE_OPEN_TRUNCATED to base::CreatePlatformFile should
automatically truncate the file to size-0.

The reason I needed to call base::TruncatePlatformFile in DoTruncateOnFileThread
is for handling non-zero truncation.

[zel, 2012/06/27 22:20:45]

I see. Done.

+    const FilePath& local_cache_path,
+    base::PlatformFile* platform_file,
+    base::PlatformFileError* result) {
+  base::PlatformFile file = base::CreatePlatformFile(
+      local_cache_path,
+      base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE,
+      NULL,
+      result);
+  if (*result == base::PLATFORM_FILE_OK) {
+    DCHECK_NE(base::kInvalidPlatformFileValue, file);
+    if (!base::TruncatePlatformFile(file, 0)) {
+      base::ClosePlatformFile(file);
+      *result = base::PLATFORM_FILE_ERROR_FAILED;
+      file = base::kInvalidPlatformFileValue;
+    }
+  }
+  *platform_file = file;
+}
+
 void DoTruncateOnFileThread(
     const FilePath& local_cache_path,
     int64 length,
     base::PlatformFileError* result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   base::PlatformFile file = base::CreatePlatformFile(
       local_cache_path,
       base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE,
       NULL,
       result);
   if (*result == base::PLATFORM_FILE_OK) {
     DCHECK_NE(base::kInvalidPlatformFileValue, file);
     if (!base::TruncatePlatformFile(file, length))
       *result = base::PLATFORM_FILE_ERROR_FAILED;
     base::ClosePlatformFile(file);
   }
 }
 
 void DidCloseFileForTruncate(
-    const fileapi::FileSystemOperationInterface::StatusCallback& callback,
+    const FileSystemOperationInterface::StatusCallback& callback,
     base::PlatformFileError truncate_result,
     base::PlatformFileError close_result) {
   // Reports the first error.
   callback.Run(truncate_result == base::PLATFORM_FILE_OK ? close_result
                                                          : truncate_result);
 }
 
 }  // namespace
 
 namespace gdata {
@@ skipping 17 matching lines @@
     GDataFileSystemInterface* file_system)
     : file_system_(file_system) {
   // Should be created from the file browser extension API (AddMountFunction)
   // on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void GDataFileSystemProxy::GetFileInfo(const GURL& file_url,
     const FileSystemOperationInterface::GetMetadataCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
   FilePath file_path;
   if (!ValidateUrl(file_url, &file_path)) {
-    base::MessageLoopProxy::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback,
-                   base::PLATFORM_FILE_ERROR_NOT_FOUND,
-                   base::PlatformFileInfo(),
-                   FilePath()));
+    MessageLoopProxy::current()->PostTask(FROM_HERE,
+         base::Bind(callback,
+                    base::PLATFORM_FILE_ERROR_NOT_FOUND,
+                    base::PlatformFileInfo(),
+                    FilePath()));
     return;
   }
 
   file_system_->GetEntryInfoByPath(
       file_path,
       base::Bind(&GDataFileSystemProxy::OnGetMetadata,
                  this,
                  file_path,
                  callback));
 }
@@ skipping 77 matching lines @@
   if (!ValidateUrl(file_url, &file_path)) {
     MessageLoopProxy::current()->PostTask(FROM_HERE,
          base::Bind(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND));
     return;
   }
 
   file_system_->CreateDirectory(file_path, exclusive, recursive, callback);
 }
 
 void GDataFileSystemProxy::Truncate(const GURL& file_url, int64 length,
-    const fileapi::FileSystemOperationInterface::StatusCallback& callback) {
+    const FileSystemOperationInterface::StatusCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (length < 0) {
     MessageLoopProxy::current()->PostTask(FROM_HERE,
         base::Bind(callback, base::PLATFORM_FILE_ERROR_INVALID_OPERATION));
     return;
   }
 
   FilePath file_path;
   if (!ValidateUrl(file_url, &file_path)) {
     MessageLoopProxy::current()->PostTask(FROM_HERE,
          base::Bind(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND));
     return;
   }
 
   // TODO(kinaba): http://crbug.com/132780.
   // Optimize the cases for small |length|, at least for |length| == 0.
   // CreateWritableSnapshotFile downloads the whole content unnecessarily.
   file_system_->OpenFile(
       file_path,
       base::Bind(&GDataFileSystemProxy::OnFileOpenedForTruncate,
                  this,
                  file_path,
                  length,
                  callback));
 }
 
+void GDataFileSystemProxy::OnOpenFileForWriting(
+    int file_flags,
+    base::ProcessHandle peer_handle,
+    const FileSystemOperationInterface::OpenFileCallback& callback,
+    base::PlatformFileError open_result,
+    const FilePath& local_cache_path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (open_result != base::PLATFORM_FILE_OK) {
+    callback.Run(open_result, base::kInvalidPlatformFileValue, peer_handle);
+    return;
+  }
+
+  // Cache file prepared for modification is available. Truncate it.
+  // File operation must be done on FILE thread, so relay the operation.
+  base::PlatformFileError* result =
+      new base::PlatformFileError(base::PLATFORM_FILE_ERROR_FAILED);
+  base::PlatformFile* platform_file = new base::PlatformFile(
+      base::kInvalidPlatformFileValue);
+  bool posted = false;
+  if (file_flags & base::PLATFORM_FILE_OPEN_TRUNCATED) {

[kinaba, 2012/06/27 09:17:21]

As noted above, I don't think this branching is necessary.

[zel, 2012/06/27 22:20:45]

Done.

+    // Perform file truncate operation.
+    posted = BrowserThread::GetBlockingPool()->PostTaskAndReply(
+        FROM_HERE,
+        base::Bind(&OpenAndTruncateOnIOPool,
+                   local_cache_path,
+                   platform_file,
+                   result),
+        base::Bind(&GDataFileSystemProxy::OnOpenAndTruncate,
+                   this,
+                   peer_handle,
+                   callback,
+                   base::Owned(platform_file),
+                   base::Owned(result)));
+  } else {
+    // Perform file open operation.
+    BrowserThread::GetBlockingPool()->PostTaskAndReply(FROM_HERE,
+        base::Bind(&OpenPlatformFileOnIOPool,
+                   local_cache_path,
+                   file_flags,
+                   platform_file,
+                   result),
+        base::Bind(&OnPlatformFileOpened,
+                   callback,
+                   peer_handle,
+                   base::Owned(platform_file),
+                   base::Owned(result)));
+  }
+  DCHECK(posted);
+}
+
 void GDataFileSystemProxy::OnFileOpenedForTruncate(
     const FilePath& virtual_path,
     int64 length,
-    const fileapi::FileSystemOperationInterface::StatusCallback& callback,
+    const FileSystemOperationInterface::StatusCallback& callback,
     base::PlatformFileError open_result,
     const FilePath& local_cache_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (open_result != base::PLATFORM_FILE_OK) {
     callback.Run(open_result);
     return;
   }
 
   // Cache file prepared for modification is available. Truncate it.
@@ skipping 10 matching lines @@
           base::Bind(&GDataFileSystemProxy::DidTruncate,
                      this,
                      virtual_path,
                      callback,
                      base::Owned(result)));
   DCHECK(posted);
 }
 
 void GDataFileSystemProxy::DidTruncate(
     const FilePath& virtual_path,
-    const fileapi::FileSystemOperationInterface::StatusCallback& callback,
+    const FileSystemOperationInterface::StatusCallback& callback,
     base::PlatformFileError* truncate_result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Truncation finished. We must close the file no matter |truncate_result|
   // indicates an error or not.
   file_system_->CloseFile(virtual_path, base::Bind(&DidCloseFileForTruncate,
                                                    callback,
                                                    *truncate_result));
 }
 
+
+void GDataFileSystemProxy::OnOpenAndTruncate(
+    base::ProcessHandle peer_handle,
+    const FileSystemOperationInterface::OpenFileCallback& callback,
+    base::PlatformFile* platform_file,
+    base::PlatformFileError* truncate_result) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  callback.Run(*truncate_result, *platform_file, peer_handle);
+}
+
 void GDataFileSystemProxy::OpenFile(
     const GURL& file_url,
     int file_flags,
     base::ProcessHandle peer_handle,
     const FileSystemOperationInterface::OpenFileCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   FilePath file_path;
   if (!ValidateUrl(file_url, &file_path)) {
     MessageLoopProxy::current()->PostTask(FROM_HERE,
          base::Bind(callback,
                     base::PLATFORM_FILE_ERROR_NOT_FOUND,
                     base::kInvalidPlatformFileValue,
                     peer_handle));
     return;
   }
 
-  file_system_->GetFileByPath(file_path,
-                              base::Bind(&OnGetFileByPathForOpen,
-                                         callback,
-                                         file_flags,
-                                         peer_handle),
-                              GetDownloadDataCallback());
+  // TODO(zelidrag): Wire all other file open operations.
+  if ((file_flags & base::PLATFORM_FILE_CREATE) ||
+      (file_flags & base::PLATFORM_FILE_CREATE_ALWAYS) ||
+      (file_flags & base::PLATFORM_FILE_DELETE_ON_CLOSE)) {

[kinaba, 2012/06/27 09:17:21]

base::PLATFORM_FILE_OPEN_ALWAYS (if exist=>open else=>create) is an error, too.

[zel, 2012/06/27 22:20:45]

Done.

+    NOTIMPLEMENTED() << "File create/write operations not yet supported "
+                     << file_path.value();
+    MessageLoopProxy::current()->PostTask(FROM_HERE,
+         base::Bind(callback,
+                    base::PLATFORM_FILE_ERROR_FAILED,
+                    base::kInvalidPlatformFileValue,
+                    peer_handle));
+    return;
+  }
+
+  if ((file_flags & base::PLATFORM_FILE_OPEN) ||
+      (file_flags & base::PLATFORM_FILE_OPEN_TRUNCATED)) {
+    if ((file_flags & base::PLATFORM_FILE_OPEN_TRUNCATED) ||
+        (file_flags & base::PLATFORM_FILE_WRITE) ||
+        (file_flags & base::PLATFORM_FILE_EXCLUSIVE_WRITE)) {
+      // Open existing file for writing.
+      file_system_->OpenFile(
+          file_path,
+          base::Bind(&GDataFileSystemProxy::OnOpenFileForWriting,
+                     this,
+                     file_flags,
+                     peer_handle,
+                     callback));
+    } else {
+      // Read-only file open.
+      file_system_->GetFileByPath(file_path,
+                                  base::Bind(&OnGetFileByPathForOpen,
+                                             callback,
+                                             file_flags,
+                                             peer_handle),
+                                  GetDownloadDataCallback());
+    }
+  }

[kinaba, 2012/06/27 09:17:21]

It might be slightly safer to callback failure when none of the recognized
file_flags are set. Currently, say, if file_flags==0, then no feedback is
returned to the caller. (Though it should never happen if callers are correctly
implemented...)

[zel, 2012/06/27 22:20:45]

Done.

+  // TODO(zelidrag): Wire file create operation.
+}
+
+void GDataFileSystemProxy::NotifyFileClosed(
+    const GURL& file_url,
+    const FileSystemOperationInterface::StatusCallback& callback) {
+  FilePath file_path;
+  if (!ValidateUrl(file_url, &file_path)) {
+    MessageLoopProxy::current()->PostTask(FROM_HERE,
+         base::Bind(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND));
+    return;
+  }
+  file_system_->CloseFile(file_path, callback);
 }
 
 void GDataFileSystemProxy::CreateSnapshotFile(
     const GURL& file_url,
     const FileSystemOperationInterface::SnapshotFileCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   FilePath file_path;
   if (!ValidateUrl(file_url, &file_path)) {
     MessageLoopProxy::current()->PostTask(FROM_HERE,
@@ skipping 157 matching lines @@
 
 void GDataFileSystemProxy::CloseWritableSnapshotFile(
     const FilePath& virtual_path,
     const FilePath& local_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   file_system_->CloseFile(virtual_path, base::Bind(&OnClose, virtual_path));
 }
 
 }  // namespace gdata