Rename GDataErrorCode to DriveErrorCode, GDataFileError to DriveFileError

chrome/browser/chromeos/gdata/gdata_util.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_util.h"
 
 #include <string>
 #include <vector>
 #include <utility>
 
@@ skipping 95 matching lines @@
   Browser* browser = browser::FindLastActiveWithProfile(profile);
   if (browser) {
     browser->OpenURL(content::OpenURLParams(*edit_url, content::Referrer(),
         CURRENT_TAB, content::PAGE_TRANSITION_TYPED, false));
   }
 }
 
 // Invoked upon completion of GetEntryInfoByResourceId initiated by
 // ModifyGDataFileResourceUrl.
 void OnGetEntryInfoByResourceId(Profile* profile,
-                               const std::string& resource_id,
-                               GDataFileError error,
-                               const FilePath& /* gdata_file_path */,
-                               scoped_ptr<DriveEntryProto> entry_proto) {
+                                const std::string& resource_id,
+                                DriveFileError error,
+                                const FilePath& /* gdata_file_path */,
+                                scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (error != GDATA_FILE_OK)
+  if (error != DRIVE_FILE_OK)
     return;
 
   DCHECK(entry_proto.get());
   const std::string& base_name = entry_proto->base_name();
   const GURL edit_url = GetFileResourceUrl(resource_id, base_name);
   OpenEditURLUIThread(profile, &edit_url);
   DVLOG(1) << "OnFindEntryByResourceId " << edit_url;
 }
 
 // Invoked upon completion of GetEntryInfoByPath initiated by
 // InsertDriveCachePathPermissions.
 void OnGetEntryInfoForInsertDriveCachePathsPermissions(
     Profile* profile,
     std::vector<std::pair<FilePath, int> >* cache_paths,
     const base::Closure& callback,
-    GDataFileError error,
+    DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(profile);
   DCHECK(cache_paths);
   DCHECK(!callback.is_null());
 
   if (entry_proto.get() && !entry_proto->has_file_specific_info())
-    error = GDATA_FILE_ERROR_NOT_FOUND;
+    error = DRIVE_FILE_ERROR_NOT_FOUND;
 
   DriveCache* cache = GetDriveCache(profile);
-  if (!cache || error != GDATA_FILE_OK) {
+  if (!cache || error != DRIVE_FILE_OK) {
     callback.Run();
     return;
   }
 
   DCHECK(entry_proto.get());
   const std::string& resource_id = entry_proto->resource_id();
   const std::string& file_md5 = entry_proto->file_specific_info().file_md5();
 
   // We check permissions for raw cache file paths only for read-only
   // operations (when fileEntry.file() is called), so read only permissions
@@ skipping 252 matching lines @@
   *extra_extension = (extension_count > 1) ? extensions[extension_count - 2] :
                                              std::string();
 }
 
 bool IsDriveV2ApiEnabled() {
   static bool enabled = CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableDriveV2Api);
   return enabled;
 }
 
-base::PlatformFileError GDataFileErrorToPlatformError(
-    gdata::GDataFileError error) {
+base::PlatformFileError DriveFileErrorToPlatformError(
+    gdata::DriveFileError error) {
   switch (error) {
-    case gdata::GDATA_FILE_OK:
+    case gdata::DRIVE_FILE_OK:
       return base::PLATFORM_FILE_OK;
 
-    case gdata::GDATA_FILE_ERROR_FAILED:
+    case gdata::DRIVE_FILE_ERROR_FAILED:
       return base::PLATFORM_FILE_ERROR_FAILED;
 
-    case gdata::GDATA_FILE_ERROR_IN_USE:
+    case gdata::DRIVE_FILE_ERROR_IN_USE:
       return base::PLATFORM_FILE_ERROR_IN_USE;
 
-    case gdata::GDATA_FILE_ERROR_EXISTS:
+    case gdata::DRIVE_FILE_ERROR_EXISTS:
       return base::PLATFORM_FILE_ERROR_EXISTS;
 
-    case gdata::GDATA_FILE_ERROR_NOT_FOUND:
+    case gdata::DRIVE_FILE_ERROR_NOT_FOUND:
       return base::PLATFORM_FILE_ERROR_NOT_FOUND;
 
-    case gdata::GDATA_FILE_ERROR_ACCESS_DENIED:
+    case gdata::DRIVE_FILE_ERROR_ACCESS_DENIED:
       return base::PLATFORM_FILE_ERROR_ACCESS_DENIED;
 
-    case gdata::GDATA_FILE_ERROR_TOO_MANY_OPENED:
+    case gdata::DRIVE_FILE_ERROR_TOO_MANY_OPENED:
       return base::PLATFORM_FILE_ERROR_TOO_MANY_OPENED;
 
-    case gdata::GDATA_FILE_ERROR_NO_MEMORY:
+    case gdata::DRIVE_FILE_ERROR_NO_MEMORY:
       return base::PLATFORM_FILE_ERROR_NO_MEMORY;
 
-    case gdata::GDATA_FILE_ERROR_NO_SPACE:
+    case gdata::DRIVE_FILE_ERROR_NO_SPACE:
       return base::PLATFORM_FILE_ERROR_NO_SPACE;
 
-    case gdata::GDATA_FILE_ERROR_NOT_A_DIRECTORY:
+    case gdata::DRIVE_FILE_ERROR_NOT_A_DIRECTORY:
       return base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
 
-    case gdata::GDATA_FILE_ERROR_INVALID_OPERATION:
+    case gdata::DRIVE_FILE_ERROR_INVALID_OPERATION:
       return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
 
-    case gdata::GDATA_FILE_ERROR_SECURITY:
+    case gdata::DRIVE_FILE_ERROR_SECURITY:
       return base::PLATFORM_FILE_ERROR_SECURITY;
 
-    case gdata::GDATA_FILE_ERROR_ABORT:
+    case gdata::DRIVE_FILE_ERROR_ABORT:
       return base::PLATFORM_FILE_ERROR_ABORT;
 
-    case gdata::GDATA_FILE_ERROR_NOT_A_FILE:
+    case gdata::DRIVE_FILE_ERROR_NOT_A_FILE:
       return base::PLATFORM_FILE_ERROR_NOT_A_FILE;
 
-    case gdata::GDATA_FILE_ERROR_NOT_EMPTY:
+    case gdata::DRIVE_FILE_ERROR_NOT_EMPTY:
       return base::PLATFORM_FILE_ERROR_NOT_EMPTY;
 
-    case gdata::GDATA_FILE_ERROR_INVALID_URL:
+    case gdata::DRIVE_FILE_ERROR_INVALID_URL:
       return base::PLATFORM_FILE_ERROR_INVALID_URL;
 
-    case gdata::GDATA_FILE_ERROR_NO_CONNECTION:
+    case gdata::DRIVE_FILE_ERROR_NO_CONNECTION:
       return base::PLATFORM_FILE_ERROR_FAILED;
   }
 
   NOTREACHED();
   return base::PLATFORM_FILE_ERROR_FAILED;
 }
 
 bool GetTimeFromString(const base::StringPiece& raw_value,
                        base::Time* parsed_time) {
   base::StringPiece date;
@@ skipping 120 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (IsUnderGDataMountPoint(path)) {
     FileWriteHelper* file_write_helper = GetFileWriteHelper(profile);
     if (!file_write_helper)
       return;
     FilePath remote_path(ExtractGDataPath(path));
     file_write_helper->PrepareWritableFileAndRun(remote_path, callback);
   } else {
     if (!callback.is_null()) {
       content::BrowserThread::GetBlockingPool()->PostTask(
-          FROM_HERE, base::Bind(callback, GDATA_FILE_OK, path));
+          FROM_HERE, base::Bind(callback, DRIVE_FILE_OK, path));
     }
   }
 }
 
-GDataFileError GDataToGDataFileError(GDataErrorCode status) {
+DriveFileError GDataToDriveFileError(GDataErrorCode status) {
   switch (status) {
     case HTTP_SUCCESS:
     case HTTP_CREATED:
-      return GDATA_FILE_OK;
+      return DRIVE_FILE_OK;
     case HTTP_UNAUTHORIZED:
     case HTTP_FORBIDDEN:
-      return GDATA_FILE_ERROR_ACCESS_DENIED;
+      return DRIVE_FILE_ERROR_ACCESS_DENIED;
     case HTTP_NOT_FOUND:
-      return GDATA_FILE_ERROR_NOT_FOUND;
+      return DRIVE_FILE_ERROR_NOT_FOUND;
     case GDATA_PARSE_ERROR:
     case GDATA_FILE_ERROR:
-      return GDATA_FILE_ERROR_ABORT;
+      return DRIVE_FILE_ERROR_ABORT;
     case GDATA_NO_CONNECTION:
-      return GDATA_FILE_ERROR_NO_CONNECTION;
+      return DRIVE_FILE_ERROR_NO_CONNECTION;
     default:
-      return GDATA_FILE_ERROR_FAILED;
+      return DRIVE_FILE_ERROR_FAILED;
   }
 }
 
 void PostBlockingPoolSequencedTask(
     const tracked_objects::Location& from_here,
     base::SequencedTaskRunner* blocking_task_runner,
     const base::Closure& task) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const bool posted = blocking_task_runner->PostTask(from_here, task);
   DCHECK(posted);
 }
 
 void PostBlockingPoolSequencedTaskAndReply(
     const tracked_objects::Location& from_here,
     base::SequencedTaskRunner* blocking_task_runner,
     const base::Closure& request_task,
     const base::Closure& reply_task) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const bool posted = blocking_task_runner->PostTaskAndReply(
       from_here, request_task, reply_task);
   DCHECK(posted);
 }
 
 }  // namespace util
 }  // namespace gdata