Rename GDataErrorCode to DriveErrorCode, GDataFileError to DriveFileError

chrome/browser/chromeos/gdata/operations_base.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/operations_base.h"
 
 #include "base/json/json_reader.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
@@ skipping 101 matching lines @@
   oauth2_access_token_fetcher_->Start(
       GaiaUrls::GetInstance()->oauth2_chrome_client_id(),
       GaiaUrls::GetInstance()->oauth2_chrome_client_secret(),
       refresh_token_,
       scopes);
 }
 
 void AuthOperation::DoCancel() {
   oauth2_access_token_fetcher_->CancelRequest();
   if (!callback_.is_null())
-    callback_.Run(GDATA_CANCELLED, std::string());
+    callback_.Run(DRIVE_CANCELLED, std::string());
 }
 
 // Callback for OAuth2AccessTokenFetcher on success. |access_token| is the token
 // used to start fetching user data.
 void AuthOperation::OnGetTokenSuccess(const std::string& access_token,
                                       const base::Time& expiration_time) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   UMA_HISTOGRAM_ENUMERATION("GData.AuthSuccess",
                             kSuccessRatioHistogramSuccess,
@@ skipping 10 matching lines @@
   LOG(WARNING) << "AuthOperation: token request using refresh token failed"
                << error.ToString();
 
   // There are many ways to fail, but if the failure is due to connection,
   // it's likely that the device is off-line. We treat the error differently
   // so that the file manager works while off-line.
   if (error.state() == GoogleServiceAuthError::CONNECTION_FAILED) {
     UMA_HISTOGRAM_ENUMERATION("GData.AuthSuccess",
                               kSuccessRatioHistogramNoConnection,
                               kSuccessRatioHistogramMaxValue);
-    callback_.Run(GDATA_NO_CONNECTION, std::string());
+    callback_.Run(DRIVE_NO_CONNECTION, std::string());
   } else {
     UMA_HISTOGRAM_ENUMERATION("GData.AuthSuccess",
                               kSuccessRatioHistogramFailure,
                               kSuccessRatioHistogramMaxValue);
     callback_.Run(HTTP_UNAUTHORIZED, std::string());
   }
   NotifyFinish(OperationRegistry::OPERATION_FAILED);
 }
 
 //============================ UrlFetchOperationBase ===========================
@@ skipping 80 matching lines @@
   return std::vector<std::string>();
 }
 
 bool UrlFetchOperationBase::GetContentData(std::string* upload_content_type,
                                            std::string* upload_content) {
   return false;
 }
 
 void UrlFetchOperationBase::DoCancel() {
   url_fetcher_.reset(NULL);
-  RunCallbackOnPrematureFailure(GDATA_CANCELLED);
+  RunCallbackOnPrematureFailure(DRIVE_CANCELLED);
 }
 
-GDataErrorCode UrlFetchOperationBase::GetErrorCode(
+DriveErrorCode UrlFetchOperationBase::GetErrorCode(
     const URLFetcher* source) const {
-  GDataErrorCode code = static_cast<GDataErrorCode>(source->GetResponseCode());
+  DriveErrorCode code = static_cast<DriveErrorCode>(source->GetResponseCode());
   if (code == HTTP_SUCCESS && !source->GetStatus().is_success()) {
     // If the HTTP response code is SUCCESS yet the URL request failed, it is
     // likely that the failure is due to loss of connection.
-    code = GDATA_NO_CONNECTION;
+    code = DRIVE_NO_CONNECTION;
   }
   return code;
 }
 
 void UrlFetchOperationBase::OnProcessURLFetchResultsComplete(bool result) {
   if (result)
     NotifySuccessToOperationRegistry();
   else
     NotifyFinish(OperationRegistry::OPERATION_FAILED);
 }
 
 void UrlFetchOperationBase::OnURLFetchComplete(const URLFetcher* source) {
-  GDataErrorCode code = GetErrorCode(source);
+  DriveErrorCode code = GetErrorCode(source);
   DVLOG(1) << "Response headers:\n" << GetResponseHeadersAsString(source);
 
   if (code == HTTP_UNAUTHORIZED) {
     if (!re_authenticate_callback_.is_null() &&
         ++re_authenticate_count_ <= kMaxReAuthenticateAttemptsPerOperation) {
       re_authenticate_callback_.Run(this);
       return;
     }
 
     OnAuthFailed(code);
     return;
   }
 
   // Overridden by each specialization
   ProcessURLFetchResults(source);
 }
 
 void UrlFetchOperationBase::NotifySuccessToOperationRegistry() {
   NotifyFinish(OperationRegistry::OPERATION_COMPLETED);
 }
 
 void UrlFetchOperationBase::NotifyStartToOperationRegistry() {
   NotifyStart();
 }
 
-void UrlFetchOperationBase::OnAuthFailed(GDataErrorCode code) {
+void UrlFetchOperationBase::OnAuthFailed(DriveErrorCode code) {
   RunCallbackOnPrematureFailure(code);
 
   // Notify authentication failed.
   NotifyAuthFailed();
 
   // Check if this failed before we even started fetching. If so, register
   // for start so we can properly unregister with finish.
   if (!started_)
     NotifyStart();
 
@@ skipping 29 matching lines @@
                                            const GURL& document_url)
     : UrlFetchOperationBase(registry),
       callback_(callback),
       document_url_(document_url) {
 }
 
 EntryActionOperation::~EntryActionOperation() {}
 
 void EntryActionOperation::ProcessURLFetchResults(const URLFetcher* source) {
   if (!callback_.is_null()) {
-    GDataErrorCode code = GetErrorCode(source);
+    DriveErrorCode code = GetErrorCode(source);
     callback_.Run(code, document_url_);
   }
   const bool success = true;
   OnProcessURLFetchResultsComplete(success);
 }
 
-void EntryActionOperation::RunCallbackOnPrematureFailure(GDataErrorCode code) {
+void EntryActionOperation::RunCallbackOnPrematureFailure(DriveErrorCode code) {
   if (!callback_.is_null())
     callback_.Run(code, document_url_);
 }
 
 //============================== GetDataOperation ==============================
 
 GetDataOperation::GetDataOperation(OperationRegistry* registry,
                                    const GetDataCallback& callback)
     : UrlFetchOperationBase(registry),
       callback_(callback),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
 }
 
 GetDataOperation::~GetDataOperation() {}
 
 void GetDataOperation::ProcessURLFetchResults(const URLFetcher* source) {
   std::string data;
   source->GetResponseAsString(&data);
   scoped_ptr<base::Value> root_value;
-  GDataErrorCode fetch_error_code = GetErrorCode(source);
+  DriveErrorCode fetch_error_code = GetErrorCode(source);
 
   switch (fetch_error_code) {
     case HTTP_SUCCESS:
     case HTTP_CREATED:
       ParseResponse(fetch_error_code, data);
       break;
     default:
       RunCallback(fetch_error_code, scoped_ptr<base::Value>());
       const bool success = false;
       OnProcessURLFetchResultsComplete(success);
       break;
   }
 }
 
 void GetDataOperation::RunCallbackOnPrematureFailure(
-    GDataErrorCode fetch_error_code) {
+    DriveErrorCode fetch_error_code) {
   if (!callback_.is_null()) {
     scoped_ptr<base::Value> root_value;
     callback_.Run(fetch_error_code, root_value.Pass());
   }
 }
 
-void GetDataOperation::ParseResponse(GDataErrorCode fetch_error_code,
+void GetDataOperation::ParseResponse(DriveErrorCode fetch_error_code,
                                      const std::string& data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Uses this hack to avoid deep-copy of json object because json might be so
   // big. This pointer of scped_ptr is to ensure a deletion of the parsed json
   // value object.
   scoped_ptr<base::Value>* parsed_value = new scoped_ptr<base::Value>();
 
   BrowserThread::PostBlockingPoolTaskAndReply(
       FROM_HERE,
       base::Bind(&ParseJsonOnBlockingPool,
                  data,
                  parsed_value),
       base::Bind(&GetDataOperation::OnDataParsed,
                  weak_ptr_factory_.GetWeakPtr(),
                  fetch_error_code,
                  base::Owned(parsed_value)));
 }
 
 void GetDataOperation::OnDataParsed(
-    gdata::GDataErrorCode fetch_error_code,
+    gdata::DriveErrorCode fetch_error_code,
     scoped_ptr<base::Value>* value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   bool success = true;
   if (!value->get()) {
-    fetch_error_code = gdata::GDATA_PARSE_ERROR;
+    fetch_error_code = gdata::DRIVE_PARSE_ERROR;
     success = false;
   }
 
   // The ownership of the parsed json object is transfered to RunCallBack(),
   // keeping the ownership of the |value| here.
   RunCallback(fetch_error_code, value->Pass());
 
   DCHECK(!value->get());
 
   OnProcessURLFetchResultsComplete(success);
   // |value| will be deleted after return because it is base::Owned()'d.
 }
 
-void GetDataOperation::RunCallback(GDataErrorCode fetch_error_code,
+void GetDataOperation::RunCallback(DriveErrorCode fetch_error_code,
                                    scoped_ptr<base::Value> value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!callback_.is_null())
     callback_.Run(fetch_error_code, value.Pass());
 }
 
 }  // namespace gdata