Rename GDataErrorCode to DriveErrorCode, GDataFileError to DriveFileError

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 46 matching lines @@
     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,
-    GDataFileError gdata_error,
+    DriveFileError gdata_error,
     const FilePath& local_path,
     const std::string& unused_mime_type,
     DriveFileType file_type) {
   base::PlatformFileError error =
-      util::GDataFileErrorToPlatformError(gdata_error);
+      util::DriveFileErrorToPlatformError(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(&OpenPlatformFileOnIOPool,
                  local_path,
                  file_flags,
                  platform_file,
                  open_error),
       base::Bind(&OnPlatformFileOpened,
                  callback,
                  peer_handle,
                  base::Owned(platform_file),
                  base::Owned(open_error)));
 }
 
 // Helper function to run SnapshotFileCallback from
 // GDataFileSystemProxy::CreateSnapshotFile().
 void CallSnapshotFileCallback(
     const FileSystemOperationInterface::SnapshotFileCallback& callback,
     const base::PlatformFileInfo& file_info,
-    GDataFileError gdata_error,
+    DriveFileError gdata_error,
     const FilePath& local_path,
     const std::string& unused_mime_type,
     DriveFileType file_type) {
   scoped_refptr<ShareableFileReference> file_ref;
   base::PlatformFileError error =
-      util::GDataFileErrorToPlatformError(gdata_error);
+      util::DriveFileErrorToPlatformError(gdata_error);
 
   // If the file is a hosted document, a temporary JSON file is created to
   // represent the document. The JSON file is not cached and its lifetime
   // is managed by ShareableFileReference.
   if (error == base::PLATFORM_FILE_OK && file_type == HOSTED_DOCUMENT) {
     file_ref = ShareableFileReference::GetOrCreate(
         local_path, ShareableFileReference::DELETE_ON_FINAL_RELEASE,
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
   }
 
   // When reading file, last modified time specified in file info will be
   // compared to the last modified time of the local version of the drive file.
   // Since those two values don't generally match (last modification time on the
   // drive server vs. last modification time of the local, downloaded file), so
   // we have to opt out from this check. We do this by unsetting last_modified
   // value in the file info passed to the CreateSnapshot caller.
   base::PlatformFileInfo final_file_info(file_info);
   final_file_info.last_modified = base::Time();
 
   callback.Run(error, final_file_info, local_path, file_ref);
 }
 
 // Emits debug log when GDataFileSystem::CloseFile() is complete.
 void EmitDebugLogForCloseFile(const FilePath& local_path,
-                              GDataFileError error_code) {
+                              DriveFileError error_code) {
   DVLOG(1) << "Closed: " << local_path.AsUTF8Unsafe() << ": " << error_code;
 }
 
 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 FileSystemOperationInterface::StatusCallback& callback,
     base::PlatformFileError truncate_result,
-    GDataFileError close_result) {
+    DriveFileError close_result) {
   // Reports the first error.
   callback.Run(truncate_result == base::PLATFORM_FILE_OK ?
-               util::GDataFileErrorToPlatformError(close_result) :
+               util::DriveFileErrorToPlatformError(close_result) :
                truncate_result);
 }
 
 }  // namespace
 
 base::FileUtilProxy::Entry DriveEntryProtoToFileUtilProxyEntry(
     const DriveEntryProto& proto) {
   base::PlatformFileInfo file_info;
   DriveEntry::ConvertProtoToPlatformFileInfo(proto.file_info(), &file_info);
 
@@ skipping 180 matching lines @@
                  this,
                  file_path,
                  length,
                  callback));
 }
 
 void GDataFileSystemProxy::OnOpenFileForWriting(
     int file_flags,
     base::ProcessHandle peer_handle,
     const FileSystemOperationInterface::OpenFileCallback& callback,
-    GDataFileError gdata_error,
+    DriveFileError gdata_error,
     const FilePath& local_cache_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   base::PlatformFileError error =
-      util::GDataFileErrorToPlatformError(gdata_error);
+      util::DriveFileErrorToPlatformError(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);
@@ skipping 11 matching lines @@
                    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) {
+    DriveFileError gdata_error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   base::PlatformFileError create_result =
-      util::GDataFileErrorToPlatformError(gdata_error);
+      util::DriveFileErrorToPlatformError(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,
+    DriveFileError open_result,
     const FilePath& local_cache_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  if (open_result != GDATA_FILE_OK) {
-    callback.Run(util::GDataFileErrorToPlatformError(open_result));
+  if (open_result != DRIVE_FILE_OK) {
+    callback.Run(util::DriveFileErrorToPlatformError(open_result));
     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);
   bool posted = BrowserThread::GetMessageLoopProxyForThread(
       BrowserThread::FILE)->PostTaskAndReply(
           FROM_HERE,
@@ skipping 128 matching lines @@
       file_path,
       base::Bind(&GDataFileSystemProxy::OnGetEntryInfoByPath,
                  this,
                  file_path,
                  callback));
 }
 
 void GDataFileSystemProxy::OnGetEntryInfoByPath(
     const FilePath& entry_path,
     const FileSystemOperationInterface::SnapshotFileCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  if (error != GDATA_FILE_OK || !entry_proto.get()) {
+  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(),
                     scoped_refptr<ShareableFileReference>(NULL)));
     return;
   }
 
   base::PlatformFileInfo file_info;
@@ skipping 42 matching lines @@
   // what platform you're on.
   if (!url.is_valid() || url.type() != fileapi::kFileSystemTypeDrive) {
     return false;
   }
   *file_path = url.virtual_path();
   return true;
 }
 
 void GDataFileSystemProxy::OnStatusCallback(
     const fileapi::FileSystemOperationInterface::StatusCallback& callback,
-    GDataFileError error) {
-  callback.Run(util::GDataFileErrorToPlatformError(error));
+    DriveFileError error) {
+  callback.Run(util::DriveFileErrorToPlatformError(error));
 }
 
 void GDataFileSystemProxy::OnGetMetadata(
     const FilePath& file_path,
     const FileSystemOperationInterface::GetMetadataCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  if (error != GDATA_FILE_OK) {
-    callback.Run(util::GDataFileErrorToPlatformError(error),
+  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 GDataFileSystemProxy::OnReadDirectory(
     const FileSystemOperationInterface::ReadDirectoryCallback&
     callback,
-    GDataFileError error,
+    DriveFileError error,
     bool hide_hosted_documents,
     scoped_ptr<DriveEntryProtoVector> proto_entries) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  if (error != GDATA_FILE_OK) {
-    callback.Run(util::GDataFileErrorToPlatformError(error),
+  if (error != DRIVE_FILE_OK) {
+    callback.Run(util::DriveFileErrorToPlatformError(error),
                  std::vector<base::FileUtilProxy::Entry>(),
                  false);
     return;
   }
   DCHECK(proto_entries.get());
 
   std::vector<base::FileUtilProxy::Entry> entries;
   // Convert gdata files to something File API stack can understand.
   for (size_t i = 0; i < proto_entries->size(); ++i) {
     const DriveEntryProto& proto = (*proto_entries)[i];
     if (proto.has_file_specific_info() &&
         proto.file_specific_info().is_hosted_document() &&
         hide_hosted_documents) {
       continue;
     }
     entries.push_back(DriveEntryProtoToFileUtilProxyEntry(proto));
   }
 
   callback.Run(base::PLATFORM_FILE_OK, entries, false);
 }
 
 void GDataFileSystemProxy::OnCreateWritableSnapshotFile(
     const FilePath& virtual_path,
     const fileapi::WritableSnapshotFile& callback,
-    GDataFileError result,
+    DriveFileError result,
     const FilePath& local_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   scoped_refptr<ShareableFileReference> file_ref;
 
-  if (result == GDATA_FILE_OK) {
+  if (result == DRIVE_FILE_OK) {
     file_ref = ShareableFileReference::GetOrCreate(
         local_path,
         ShareableFileReference::DONT_DELETE_ON_FINAL_RELEASE,
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
     file_ref->AddFinalReleaseCallback(
         base::Bind(&GDataFileSystemProxy::CloseWritableSnapshotFile,
                    this,
                    virtual_path));
   }
 
   callback.Run(
-      util::GDataFileErrorToPlatformError(result), local_path, file_ref);
+      util::DriveFileErrorToPlatformError(result), local_path, file_ref);
 }
 
 void GDataFileSystemProxy::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