Rename GDataErrorCode to DriveErrorCode, GDataFileError to DriveFileError

chrome/browser/chromeos/extensions/file_browser_private_api.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/extensions/file_browser_private_api.h"
 
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 380 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Add gdata mount point immediately when we kick of first instance of file
   // manager. The actual mount event will be sent to UI only when we perform
   // proper authentication.
   if (gdata::util::IsGDataAvailable(profile_))
     AddGDataMountPoint(profile_, extension_id(), render_view_host());
   DictionaryValue* dict = new DictionaryValue();
   SetResult(dict);
   dict->SetString("name", name);
   dict->SetString("path", root_path.spec());
-  dict->SetInteger("error", gdata::GDATA_FILE_OK);
+  dict->SetInteger("error", gdata::DRIVE_FILE_OK);
   SendResponse(true);
 }
 
 void RequestLocalFileSystemFunction::RespondFailedOnUIThread(
     base::PlatformFileError error_code) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   error_ = base::StringPrintf(kFileError, static_cast<int>(error_code));
   SendResponse(false);
 }
 
@@ skipping 688 matching lines @@
       gdata::GDataSystemServiceFactory::GetForProfile(profile_);
   gdata::DriveCache* cache = system_service ? system_service->cache() : NULL;
   if (cache && cache->IsUnderDriveCacheDirectory(source_path)) {
     cache->SetMountedStateOnUIThread(
         source_path,
         true,
         base::Bind(&AddMountFunction::OnMountedStateSet, this, mount_type_str,
                    display_name));
   } else {
     OnMountedStateSet(mount_type_str, display_name,
-                      gdata::GDATA_FILE_OK, source_path);
+                      gdata::DRIVE_FILE_OK, source_path);
   }
 }
 
 void AddMountFunction::OnMountedStateSet(const std::string& mount_type,
                                          const FilePath::StringType& file_name,
-                                         gdata::GDataFileError error,
+                                         gdata::DriveFileError error,
                                          const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DiskMountManager* disk_mount_manager = DiskMountManager::GetInstance();
   // Pass back the actual source path of the mount point.
   SetResult(Value::CreateStringValue(file_path.value()));
   SendResponse(true);
   // MountPath() takes a std::string.
   disk_mount_manager->MountPath(file_path.AsUTF8Unsafe(),
                                 FilePath(file_name).Extension(), file_name,
                                 DiskMountManager::MountTypeFromString(
@@ skipping 113 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(
             &GetSizeStatsFunction::CallGetSizeStatsOnFileThread,
             this,
             files[0].file_path.value()));
   }
 }
 
 void GetSizeStatsFunction::GetGDataAvailableSpaceCallback(
-    gdata::GDataFileError error,
+    gdata::DriveFileError error,
     int64 bytes_total,
     int64 bytes_used) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (error == gdata::GDATA_FILE_OK) {
+  if (error == gdata::DRIVE_FILE_OK) {
     int64 bytes_remaining = bytes_total - bytes_used;
     GetSizeStatsCallbackOnUIThread(static_cast<size_t>(bytes_total/1024),
                                    static_cast<size_t>(bytes_remaining/1024));
   } else {
     error_ = base::StringPrintf(kFileError, static_cast<int>(error));
     SendResponse(false);
   }
 }
 
 void GetSizeStatsFunction::CallGetSizeStatsOnFileThread(
@@ skipping 454 matching lines @@
 
 void GetGDataFilePropertiesFunction::DoOperation(
     const FilePath& file_path,
     base::DictionaryValue* property_dict,
     scoped_ptr<gdata::DriveEntryProto> entry_proto) {
   DCHECK(property_dict);
 
   // Nothing to do here so simply call OnOperationComplete().
   OnOperationComplete(file_path,
                       property_dict,
-                      gdata::GDATA_FILE_OK,
+                      gdata::DRIVE_FILE_OK,
                       entry_proto.Pass());
 }
 
 bool GetGDataFilePropertiesFunction::RunImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (args_->GetSize() != 1)
     return false;
 
   PrepareResults();
   return true;
@@ skipping 41 matching lines @@
   current_index_++;
 
   // Could be called from callback. Let finish operation.
   MessageLoop::current()->PostTask(FROM_HERE,
       Bind(&GetGDataFilePropertiesFunction::GetNextFileProperties, this));
 }
 
 void GetGDataFilePropertiesFunction::OnGetFileInfo(
     const FilePath& file_path,
     base::DictionaryValue* property_dict,
-    gdata::GDataFileError error,
+    gdata::DriveFileError error,
     scoped_ptr<gdata::DriveEntryProto> entry_proto) {
   DCHECK(property_dict);
 
   if (entry_proto.get() && !entry_proto->has_file_specific_info())
-    error = gdata::GDATA_FILE_ERROR_NOT_FOUND;
+    error = gdata::DRIVE_FILE_ERROR_NOT_FOUND;
 
-  if (error == gdata::GDATA_FILE_OK)
+  if (error == gdata::DRIVE_FILE_OK)
     DoOperation(file_path, property_dict, entry_proto.Pass());
   else
     OnOperationComplete(file_path, property_dict, error, entry_proto.Pass());
 }
 
 void GetGDataFilePropertiesFunction::OnOperationComplete(
     const FilePath& file_path,
     base::DictionaryValue* property_dict,
-    gdata::GDataFileError error,
+    gdata::DriveFileError error,
     scoped_ptr<gdata::DriveEntryProto> entry_proto) {
   if (entry_proto.get() && !entry_proto->has_file_specific_info())
-    error = gdata::GDATA_FILE_ERROR_NOT_FOUND;
+    error = gdata::DRIVE_FILE_ERROR_NOT_FOUND;
 
-  if (error != gdata::GDATA_FILE_OK) {
+  if (error != gdata::DRIVE_FILE_OK) {
     property_dict->SetInteger("errorCode", error);
     CompleteGetFileProperties();
     return;
   }
   DCHECK(entry_proto.get());
 
   const gdata::DriveFileSpecificInfo& file_specific_info =
       entry_proto->file_specific_info();
   property_dict->SetString("thumbnailUrl", file_specific_info.thumbnail_url());
   if (!file_specific_info.alternate_url().empty())
@@ skipping 110 matching lines @@
   if (set_pin_)
     system_service->cache()->PinOnUIThread(resource_id, md5, callback);
   else
     system_service->cache()->UnpinOnUIThread(resource_id, md5, callback);
 }
 
 void PinGDataFileFunction::OnPinStateSet(
     const FilePath& path,
     base::DictionaryValue* properties,
     scoped_ptr<gdata::DriveEntryProto> entry_proto,
-    gdata::GDataFileError error,
+    gdata::DriveFileError error,
     const std::string& /* resource_id */,
     const std::string& /* md5 */) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   OnOperationComplete(path, properties, error, entry_proto.Pass());
 }
 
 GetFileLocationsFunction::GetFileLocationsFunction() {
 }
 
@@ skipping 95 matching lines @@
   // Get the file on the top of the queue.
   FilePath gdata_path = remaining_gdata_paths_.front();
   system_service->file_system()->GetFileByPath(
       gdata_path,
       base::Bind(&GetGDataFilesFunction::OnFileReady, this),
       gdata::GetContentCallback());
 }
 
 
 void GetGDataFilesFunction::OnFileReady(
-    gdata::GDataFileError error,
+    gdata::DriveFileError error,
     const FilePath& local_path,
     const std::string& unused_mime_type,
     gdata::DriveFileType file_type) {
   FilePath gdata_path = remaining_gdata_paths_.front();
 
-  if (error == gdata::GDATA_FILE_OK) {
+  if (error == gdata::DRIVE_FILE_OK) {
     local_paths_->Append(Value::CreateStringValue(local_path.value()));
     DVLOG(1) << "Got " << gdata_path.value() << " as " << local_path.value();
 
     // TODO(benchan): If the file is a hosted document, a temporary JSON file
     // is created to represent the document. The JSON file is not cached and
     // should be deleted after use. We need to somehow communicate with
     // file_manager.js to manage the lifetime of the temporary file.
     // See crosbug.com/28058.
   } else {
     local_paths_->Append(Value::CreateStringValue(""));
@@ skipping 160 matching lines @@
         destination_file,
         base::Bind(&TransferFileFunction::OnTransferCompleted, this));
   } else {
     // Local-to-local or gdata-to-gdata file transfers should be done via
     // FileEntry.copyTo in the File API and are thus not supported here.
     NOTREACHED();
     SendResponse(false);
   }
 }
 
-void TransferFileFunction::OnTransferCompleted(gdata::GDataFileError error) {
-  if (error == gdata::GDATA_FILE_OK) {
+void TransferFileFunction::OnTransferCompleted(gdata::DriveFileError error) {
+  if (error == gdata::DRIVE_FILE_OK) {
     SendResponse(true);
   } else {
     error_ = base::StringPrintf("%d", static_cast<int>(
         fileapi::PlatformFileErrorToWebFileError(
-            gdata::util::GDataFileErrorToPlatformError(error))));
+            gdata::util::DriveFileErrorToPlatformError(error))));
     SendResponse(false);
   }
 }
 
 // Read GData-related preferences.
 bool GetGDataPreferencesFunction::RunImpl() {
   scoped_ptr<DictionaryValue> value(new DictionaryValue());
 
   const PrefService* service = profile_->GetPrefs();
 
@@ skipping 71 matching lines @@
     SendResponse(false);
     return;
   }
 
   system_service->file_system()->Search(
       query_, GURL(next_feed_),
       base::Bind(&SearchDriveFunction::OnSearch, this));
 }
 
 void SearchDriveFunction::OnSearch(
-    gdata::GDataFileError error,
+    gdata::DriveFileError error,
     const GURL& next_feed,
     scoped_ptr<std::vector<gdata::SearchResultInfo> > results) {
-  if (error != gdata::GDATA_FILE_OK) {
+  if (error != gdata::DRIVE_FILE_OK) {
     SendResponse(false);
     return;
   }
 
   DCHECK(results.get());
 
   base::ListValue* entries = new ListValue();
   // Convert gdata files to something File API stack can understand.
   for (size_t i = 0; i < results->size(); ++i) {
     DictionaryValue* entry = new DictionaryValue();
@@ skipping 61 matching lines @@
   gdata::GDataSystemService* system_service =
       gdata::GDataSystemServiceFactory::GetForProfile(profile_);
   if (!system_service || !system_service->file_system())
     return false;
 
   FilePath directory_path = GetVirtualPathFromURL(GURL(file_url_as_string));
   system_service->file_system()->RequestDirectoryRefresh(directory_path);
 
   return true;
 }