Rename FileSystemOperationInterface to FileSystemOperation

chrome/browser/chromeos/gdata/drive_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/drive_file_system_proxy.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/platform_file.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/gdata/drive.pb.h"
 #include "chrome/browser/chromeos/gdata/drive_file_system_interface.h"
 #include "chrome/browser/chromeos/gdata/drive_files.h"
 #include "chrome/browser/chromeos/gdata/gdata_system_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "webkit/blob/shareable_file_reference.h"
 #include "webkit/fileapi/file_system_file_util_proxy.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/file_system_util.h"
 
 using base::MessageLoopProxy;
 using content::BrowserThread;
 using fileapi::FileSystemURL;
-using fileapi::FileSystemOperationInterface;
+using fileapi::FileSystemOperation;
 using webkit_blob::ShareableFileReference;
 
 namespace gdata {
 
 namespace {
 
 const char kDriveRootDirectory[] = "drive";
 const char kFeedField[] = "feed";
 
 // Helper function that creates platform file on blocking IO thread pool.
 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 OpenPlatformFileOnIOPool() on
 // IO thread.
 void OnPlatformFileOpened(
-    const FileSystemOperationInterface::OpenFileCallback& callback,
+    const FileSystemOperation::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
 // DriveFileSystemProxy::OpenFile().
 void OnGetFileByPathForOpen(
-    const FileSystemOperationInterface::OpenFileCallback& callback,
+    const FileSystemOperation::OpenFileCallback& callback,
     int file_flags,
     base::ProcessHandle peer_handle,
     DriveFileError file_error,
     const FilePath& local_path,
     const std::string& unused_mime_type,
     DriveFileType file_type) {
   base::PlatformFileError error =
       util::DriveFileErrorToPlatformError(file_error);
   if (error != base::PLATFORM_FILE_OK) {
     callback.Run(error, base::kInvalidPlatformFileValue, peer_handle);
@@ skipping 13 matching lines @@
       base::Bind(&OnPlatformFileOpened,
                  callback,
                  peer_handle,
                  base::Owned(platform_file),
                  base::Owned(open_error)));
 }
 
 // Helper function to run SnapshotFileCallback from
 // DriveFileSystemProxy::CreateSnapshotFile().
 void CallSnapshotFileCallback(
-    const FileSystemOperationInterface::SnapshotFileCallback& callback,
+    const FileSystemOperation::SnapshotFileCallback& callback,
     const base::PlatformFileInfo& file_info,
     DriveFileError file_error,
     const FilePath& local_path,
     const std::string& unused_mime_type,
     DriveFileType file_type) {
   scoped_refptr<ShareableFileReference> file_ref;
   base::PlatformFileError error =
       util::DriveFileErrorToPlatformError(file_error);
 
   // If the file is a hosted document, a temporary JSON file is created to
@@ skipping 36 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 FileSystemOperationInterface::StatusCallback& callback,
+    const FileSystemOperation::StatusCallback& callback,
     base::PlatformFileError truncate_result,
     DriveFileError close_result) {
   // Reports the first error.
   callback.Run(truncate_result == base::PLATFORM_FILE_OK ?
                util::DriveFileErrorToPlatformError(close_result) :
                truncate_result);
 }
 
 }  // namespace
 
@@ skipping 14 matching lines @@
 
 DriveFileSystemProxy::DriveFileSystemProxy(
     DriveFileSystemInterface* 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 DriveFileSystemProxy::GetFileInfo(const FileSystemURL& file_url,
-    const FileSystemOperationInterface::GetMetadataCallback& callback) {
+    const FileSystemOperation::GetMetadataCallback& 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::PlatformFileInfo(),
                     FilePath()));
     return;
   }
 
   file_system_->GetEntryInfoByPath(
       file_path,
       base::Bind(&DriveFileSystemProxy::OnGetMetadata,
                  this,
                  file_path,
                  callback));
 }
 
 void DriveFileSystemProxy::Copy(const FileSystemURL& src_file_url,
     const FileSystemURL& dest_file_url,
-    const FileSystemOperationInterface::StatusCallback& callback) {
+    const FileSystemOperation::StatusCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   FilePath src_file_path, dest_file_path;
   if (!ValidateUrl(src_file_url, &src_file_path) ||
       !ValidateUrl(dest_file_url, &dest_file_path)) {
     MessageLoopProxy::current()->PostTask(FROM_HERE,
          base::Bind(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND));
     return;
   }
 
   file_system_->Copy(
       src_file_path,
       dest_file_path,
       base::Bind(&DriveFileSystemProxy::OnStatusCallback, this, callback));
 }
 
 void DriveFileSystemProxy::Move(const FileSystemURL& src_file_url,
     const FileSystemURL& dest_file_url,
-    const FileSystemOperationInterface::StatusCallback& callback) {
+    const FileSystemOperation::StatusCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   FilePath src_file_path, dest_file_path;
   if (!ValidateUrl(src_file_url, &src_file_path) ||
       !ValidateUrl(dest_file_url, &dest_file_path)) {
     MessageLoopProxy::current()->PostTask(FROM_HERE,
          base::Bind(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND));
     return;
   }
 
   file_system_->Move(
       src_file_path,
       dest_file_path,
       base::Bind(&DriveFileSystemProxy::OnStatusCallback, this, callback));
 }
 
 void DriveFileSystemProxy::ReadDirectory(const FileSystemURL& file_url,
-    const FileSystemOperationInterface::ReadDirectoryCallback& callback) {
+    const FileSystemOperation::ReadDirectoryCallback& 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,
                    std::vector<base::FileUtilProxy::Entry>(),
                    false));
     return;
   }
 
   file_system_->ReadDirectoryByPath(
       file_path,
       base::Bind(&DriveFileSystemProxy::OnReadDirectory,
                  this,
                  callback));
 }
 
 void DriveFileSystemProxy::Remove(const FileSystemURL& file_url, bool recursive,
-    const FileSystemOperationInterface::StatusCallback& callback) {
+    const FileSystemOperation::StatusCallback& 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));
     return;
   }
 
   file_system_->Remove(
       file_path,
       recursive,
       base::Bind(&DriveFileSystemProxy::OnStatusCallback, this, callback));
 }
 
 void DriveFileSystemProxy::CreateDirectory(
     const FileSystemURL& file_url,
     bool exclusive,
     bool recursive,
-    const FileSystemOperationInterface::StatusCallback& callback) {
+    const FileSystemOperation::StatusCallback& 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));
     return;
   }
 
   file_system_->CreateDirectory(
       file_path,
       exclusive,
       recursive,
       base::Bind(&DriveFileSystemProxy::OnStatusCallback, this, callback));
 }
 
 void DriveFileSystemProxy::CreateFile(
     const FileSystemURL& file_url,
     bool exclusive,
-    const FileSystemOperationInterface::StatusCallback& callback) {
+    const FileSystemOperation::StatusCallback& 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));
     return;
   }
 
   file_system_->CreateFile(
       file_path,
       exclusive,
       base::Bind(&DriveFileSystemProxy::OnStatusCallback, this, callback));
 }
 
 void DriveFileSystemProxy::Truncate(
     const FileSystemURL& file_url, int64 length,
-    const FileSystemOperationInterface::StatusCallback& callback) {
+    const FileSystemOperation::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)) {
@@ skipping 10 matching lines @@
       base::Bind(&DriveFileSystemProxy::OnFileOpenedForTruncate,
                  this,
                  file_path,
                  length,
                  callback));
 }
 
 void DriveFileSystemProxy::OnOpenFileForWriting(
     int file_flags,
     base::ProcessHandle peer_handle,
-    const FileSystemOperationInterface::OpenFileCallback& callback,
+    const FileSystemOperation::OpenFileCallback& callback,
     DriveFileError file_error,
     const FilePath& local_cache_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   base::PlatformFileError error =
       util::DriveFileErrorToPlatformError(file_error);
 
   if (error != base::PLATFORM_FILE_OK) {
     callback.Run(error, base::kInvalidPlatformFileValue, peer_handle);
     return;
@@ skipping 16 matching lines @@
                    peer_handle,
                    base::Owned(platform_file),
                    base::Owned(result)));
   DCHECK(posted);
 }
 
 void DriveFileSystemProxy::OnCreateFileForOpen(
     const FilePath& file_path,
     int file_flags,
     base::ProcessHandle peer_handle,
-    const FileSystemOperationInterface::OpenFileCallback& callback,
+    const FileSystemOperation::OpenFileCallback& callback,
     DriveFileError file_error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   base::PlatformFileError create_result =
       util::DriveFileErrorToPlatformError(file_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.
@@ skipping 11 matching lines @@
       base::Bind(&DriveFileSystemProxy::OnOpenFileForWriting,
                  this,
                  file_flags,
                  peer_handle,
                  callback));
 }
 
 void DriveFileSystemProxy::OnFileOpenedForTruncate(
     const FilePath& virtual_path,
     int64 length,
-    const fileapi::FileSystemOperationInterface::StatusCallback& callback,
+    const fileapi::FileSystemOperation::StatusCallback& callback,
     DriveFileError open_result,
     const FilePath& local_cache_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (open_result != DRIVE_FILE_OK) {
     callback.Run(util::DriveFileErrorToPlatformError(open_result));
     return;
   }
 
   // Cache file prepared for modification is available. Truncate it.
@@ skipping 10 matching lines @@
           base::Bind(&DriveFileSystemProxy::DidTruncate,
                      this,
                      virtual_path,
                      callback,
                      base::Owned(result)));
   DCHECK(posted);
 }
 
 void DriveFileSystemProxy::DidTruncate(
     const FilePath& virtual_path,
-    const FileSystemOperationInterface::StatusCallback& callback,
+    const FileSystemOperation::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 DriveFileSystemProxy::OpenFile(
     const FileSystemURL& file_url,
     int file_flags,
     base::ProcessHandle peer_handle,
-    const FileSystemOperationInterface::OpenFileCallback& callback) {
+    const FileSystemOperation::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;
@@ skipping 61 matching lines @@
   FilePath file_path;
   if (!ValidateUrl(url, &file_path))
     return;
 
   file_system_->CloseFile(file_path,
                           base::Bind(&EmitDebugLogForCloseFile, file_path));
 }
 
 void DriveFileSystemProxy::CreateSnapshotFile(
     const FileSystemURL& file_url,
-    const FileSystemOperationInterface::SnapshotFileCallback& callback) {
+    const FileSystemOperation::SnapshotFileCallback& 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::PlatformFileInfo(),
                     FilePath(),
                     scoped_refptr<ShareableFileReference>(NULL)));
     return;
   }
 
   file_system_->GetEntryInfoByPath(
       file_path,
       base::Bind(&DriveFileSystemProxy::OnGetEntryInfoByPath,
                  this,
                  file_path,
                  callback));
 }
 
 void DriveFileSystemProxy::OnGetEntryInfoByPath(
     const FilePath& entry_path,
-    const FileSystemOperationInterface::SnapshotFileCallback& callback,
+    const FileSystemOperation::SnapshotFileCallback& callback,
     DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (error != DRIVE_FILE_OK || !entry_proto.get()) {
     MessageLoopProxy::current()->PostTask(FROM_HERE,
          base::Bind(callback,
                     base::PLATFORM_FILE_ERROR_NOT_FOUND,
                     base::PlatformFileInfo(),
                     FilePath(),
@@ skipping 46 matching lines @@
     const FileSystemURL& url, FilePath* file_path) {
   // what platform you're on.
   if (!url.is_valid() || url.type() != fileapi::kFileSystemTypeDrive) {
     return false;
   }
   *file_path = url.virtual_path();
   return true;
 }
 
 void DriveFileSystemProxy::OnStatusCallback(
-    const fileapi::FileSystemOperationInterface::StatusCallback& callback,
+    const fileapi::FileSystemOperation::StatusCallback& callback,
     DriveFileError error) {
   callback.Run(util::DriveFileErrorToPlatformError(error));
 }
 
 void DriveFileSystemProxy::OnGetMetadata(
     const FilePath& file_path,
-    const FileSystemOperationInterface::GetMetadataCallback& callback,
+    const FileSystemOperation::GetMetadataCallback& callback,
     DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (error != DRIVE_FILE_OK) {
     callback.Run(util::DriveFileErrorToPlatformError(error),
                  base::PlatformFileInfo(),
                  FilePath());
     return;
   }
   DCHECK(entry_proto.get());
 
   base::PlatformFileInfo file_info;
   DriveEntry::ConvertProtoToPlatformFileInfo(
       entry_proto->file_info(),
       &file_info);
 
   callback.Run(base::PLATFORM_FILE_OK, file_info, file_path);
 }
 
 void DriveFileSystemProxy::OnReadDirectory(
-    const FileSystemOperationInterface::ReadDirectoryCallback&
+    const FileSystemOperation::ReadDirectoryCallback&
     callback,
     DriveFileError error,
     bool hide_hosted_documents,
     scoped_ptr<DriveEntryProtoVector> proto_entries) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (error != DRIVE_FILE_OK) {
     callback.Run(util::DriveFileErrorToPlatformError(error),
                  std::vector<base::FileUtilProxy::Entry>(),
                  false);
@@ skipping 43 matching lines @@
 void DriveFileSystemProxy::CloseWritableSnapshotFile(
     const FilePath& virtual_path,
     const FilePath& local_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   file_system_->CloseFile(virtual_path,
                           base::Bind(&EmitDebugLogForCloseFile, virtual_path));
 }
 
 }  // namespace gdata