Rename GDataErrorCode to DriveErrorCode, GDataFileError to DriveFileError

chrome/browser/chromeos/gdata/gdata_sync_client.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_sync_client.h"
 
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 
@@ skipping 303 matching lines @@
     file_system_->GetEntryInfoByResourceId(
         resource_id,
         base::Bind(&GDataSyncClient::OnGetEntryInfoByResourceId,
                    weak_ptr_factory_.GetWeakPtr(),
                    resource_id));
   }
 }
 
 void GDataSyncClient::OnGetEntryInfoByResourceId(
     const std::string& resource_id,
-    GDataFileError error,
+    DriveFileError error,
     const FilePath& /* gdata_file_path */,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (entry_proto.get() && !entry_proto->has_file_specific_info())
-    error = GDATA_FILE_ERROR_NOT_FOUND;
+    error = DRIVE_FILE_ERROR_NOT_FOUND;
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     LOG(WARNING) << "Entry not found: " << resource_id;
     return;
   }
 
   cache_->GetCacheEntryOnUIThread(
       resource_id,
       "" /* don't check MD5 */,
       base::Bind(&GDataSyncClient::OnGetCacheEntry,
                  weak_ptr_factory_.GetWeakPtr(),
                  resource_id,
@@ skipping 16 matching lines @@
   // the file is dirty (the MD5 is "local"). We should never re-fetch the
   // file when we have a locally modified version.
   if (latest_md5 != cache_entry.md5() && !cache_entry.is_dirty()) {
     cache_->RemoveOnUIThread(
         resource_id,
         base::Bind(&GDataSyncClient::OnRemove,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
-void GDataSyncClient::OnRemove(GDataFileError error,
+void GDataSyncClient::OnRemove(DriveFileError error,
                                const std::string& resource_id,
                                const std::string& md5) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     LOG(WARNING) << "Failed to remove cache entry: " << resource_id;
     return;
   }
 
   // Before fetching, we should pin this file again, so that the fetched file
   // is downloaded properly to the persistent directory and marked pinned.
   cache_->PinOnUIThread(resource_id,
                         md5,
                         base::Bind(&GDataSyncClient::OnPinned,
                                    weak_ptr_factory_.GetWeakPtr()));
 }
 
-void GDataSyncClient::OnPinned(GDataFileError error,
+void GDataSyncClient::OnPinned(DriveFileError error,
                                const std::string& resource_id,
                                const std::string& /* md5 */) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     LOG(WARNING) << "Failed to pin cache entry: " << resource_id;
     return;
   }
 
   // Finally, adding to the queue.
   AddTaskToQueue(SyncTask(FETCH, resource_id, base::Time::Now()));
   StartSyncLoop();
 }
 
 void GDataSyncClient::OnFetchFileComplete(const SyncTask& sync_task,
-                                          GDataFileError error,
+                                          DriveFileError error,
                                           const FilePath& local_path,
                                           const std::string& ununsed_mime_type,
                                           DriveFileType file_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (error == GDATA_FILE_OK) {
+  if (error == DRIVE_FILE_OK) {
     DVLOG(1) << "Fetched " << sync_task.resource_id << ": "
              << local_path.value();
   } else {
     switch (error) {
-      case GDATA_FILE_ERROR_NO_CONNECTION:
+      case DRIVE_FILE_ERROR_NO_CONNECTION:
         // Re-queue the task so that we'll retry once the connection is back.
         queue_.push_front(sync_task);
         break;
       default:
         LOG(WARNING) << "Failed to fetch " << sync_task.resource_id
                      << ": " << error;
     }
   }
 
   // Continue the loop.
   DoSyncLoop();
 }
 
 void GDataSyncClient::OnUploadFileComplete(const std::string& resource_id,
-                                           GDataFileError error) {
+                                           DriveFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (error == GDATA_FILE_OK) {
+  if (error == DRIVE_FILE_OK) {
     DVLOG(1) << "Uploaded " << resource_id;
   } else {
     // TODO(satorux): We should re-queue if the error is recoverable.
     LOG(WARNING) << "Failed to upload " << resource_id << ": " << error;
   }
 
   // Continue the loop.
   DoSyncLoop();
 }
 
@@ skipping 14 matching lines @@
                               const content::NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Resume the sync loop if gdata preferences are changed. Note that we
   // don't need to check the new values here as these will be checked in
   // ShouldStopSyncLoop() as soon as the loop is resumed.
   StartSyncLoop();
 }
 
 }  // namespace gdata