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 16 matching lines @@
 using fileapi::FileSystemURL;
 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,
     gdata::GDataFileError gdata_error,
     const FilePath& local_path,
     const std::string& unused_mime_type,
     gdata::GDataFileType file_type) {
   base::PlatformFileError error =
       gdata::util::GDataFileErrorToPlatformError(gdata_error);
   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 45 matching lines @@
       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,
     gdata::GDataFileError close_result) {
   // Reports the first error.
   callback.Run(truncate_result == base::PLATFORM_FILE_OK ?
                gdata::util::GDataFileErrorToPlatformError(close_result) :
                truncate_result);
 }
 
 }  // namespace
 
@@ skipping 18 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 FileSystemURL& 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 110 matching lines @@
   }
 
   file_system_->CreateFile(
       file_path,
       exclusive,
       base::Bind(&GDataFileSystemProxy::OnStatusCallback, this, callback));
 }
 
 void GDataFileSystemProxy::Truncate(
     const FileSystemURL& 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,
+    GDataFileError gdata_error,
+    const FilePath& local_cache_path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  base::PlatformFileError error =
+      gdata::util::GDataFileErrorToPlatformError(gdata_error);
+
+  if (error != base::PLATFORM_FILE_OK) {
+    callback.Run(error, 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 = 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::OnCreateFileForOpen(
+    const FilePath& file_path,
+    int file_flags,
+    base::ProcessHandle peer_handle,
+    const FileSystemOperationInterface::OpenFileCallback& callback,
+    GDataFileError gdata_error) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  base::PlatformFileError create_result =
+      gdata::util::GDataFileErrorToPlatformError(gdata_error);
+
+  if ((create_result == base::PLATFORM_FILE_OK) ||
+      ((create_result == base::PLATFORM_FILE_ERROR_EXISTS) &&
+       (file_flags & base::PLATFORM_FILE_CREATE_ALWAYS))) {
+    // If we are trying to always create an existing file, then
+    // if it really exists open it as truncated.
+    file_flags &= ~base::PLATFORM_FILE_CREATE;
+    file_flags &= ~base::PLATFORM_FILE_CREATE_ALWAYS;
+    file_flags |= base::PLATFORM_FILE_OPEN_TRUNCATED;
+  } else {
+    callback.Run(create_result, base::kInvalidPlatformFileValue, peer_handle);
+    return;
+  }
+
+  // Open created (or existing) file for writing.
+  file_system_->OpenFile(
+      file_path,
+      base::Bind(&GDataFileSystemProxy::OnOpenFileForWriting,
+                 this,
+                 file_flags,
+                 peer_handle,
+                 callback));
+}
+
 void GDataFileSystemProxy::OnFileOpenedForTruncate(
     const FilePath& virtual_path,
     int64 length,
     const fileapi::FileSystemOperationInterface::StatusCallback& callback,
     GDataFileError open_result,
     const FilePath& local_cache_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (open_result != GDATA_FILE_OK) {
     callback.Run(util::GDataFileErrorToPlatformError(open_result));
@@ skipping 14 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,
                  base::PlatformFileError(*truncate_result)));
 }
 
 void GDataFileSystemProxy::OpenFile(
     const FileSystemURL& 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_DELETE_ON_CLOSE)) {
+    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_ALWAYS) ||
+      (file_flags & base::PLATFORM_FILE_OPEN_TRUNCATED)) {
+    if ((file_flags & base::PLATFORM_FILE_OPEN_TRUNCATED) ||
+        (file_flags & base::PLATFORM_FILE_OPEN_ALWAYS) ||
+        (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());
+    }
+  } else if ((file_flags & base::PLATFORM_FILE_CREATE) ||
+             (file_flags & base::PLATFORM_FILE_CREATE_ALWAYS)) {
+    // Open existing file for writing.
+    file_system_->CreateFile(
+        file_path,
+        file_flags & base::PLATFORM_FILE_EXCLUSIVE_WRITE,
+        base::Bind(&GDataFileSystemProxy::OnCreateFileForOpen,
+                   this,
+                   file_path,
+                   file_flags,
+                   peer_handle,
+                   callback));
+  } else {
+    NOTREACHED() << "Unhandled file flags combination " << file_flags;
+    MessageLoopProxy::current()->PostTask(FROM_HERE,
+         base::Bind(callback,
+                    base::PLATFORM_FILE_ERROR_FAILED,
+                    base::kInvalidPlatformFileValue,
+                    peer_handle));
+  }
 }
 
 void GDataFileSystemProxy::NotifyCloseFile(const FileSystemURL& url) {
-  // TODO(kinaba,zelidrag): crbug.com/132236.
-  // Once OpenFile() for writing is implemented, we also need to implement the
-  // corresponding NotifyCloseFile for committing dirty cache.
+  FilePath file_path;
+  if (!ValidateUrl(url, &file_path))
+    return;
+
+  file_system_->CloseFile(file_path, FileOperationCallback());
 }
 
 void GDataFileSystemProxy::CreateSnapshotFile(
     const FileSystemURL& 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 168 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