Rename gdata_errorcode.h to drive_api_error_codes.h

google_apis/drive/auth_service.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 "google_apis/drive/auth_service.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 84 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
 
   LOG(WARNING) << "AuthRequest: 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) {
     RecordAuthResultHistogram(kSuccessRatioHistogramNoConnection);
-    callback_.Run(GDATA_NO_CONNECTION, std::string());
+    callback_.Run(DRIVE_NO_CONNECTION, std::string());
   } else if (error.state() == GoogleServiceAuthError::SERVICE_UNAVAILABLE) {
     RecordAuthResultHistogram(kSuccessRatioHistogramTemporaryFailure);
     callback_.Run(HTTP_FORBIDDEN, std::string());
   } else {
     // Permanent auth error.
     RecordAuthResultHistogram(kSuccessRatioHistogramFailure);
     callback_.Run(HTTP_UNAUTHORIZED, std::string());
   }
   delete this;
 }
@@ skipping 33 matching lines @@
     // We have refresh token, let's get an access token.
     new AuthRequest(oauth2_token_service_,
                     account_id_,
                     url_request_context_getter_.get(),
                     base::Bind(&AuthService::OnAuthCompleted,
                                weak_ptr_factory_.GetWeakPtr(),
                                callback),
                     scopes_);
   } else {
     base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(callback, GDATA_NOT_READY, std::string()));
+        FROM_HERE, base::Bind(callback, DRIVE_NOT_READY, std::string()));
   }
 }
 
 bool AuthService::HasAccessToken() const {
   return !access_token_.empty();
 }
 
 bool AuthService::HasRefreshToken() const {
   return has_refresh_token_;
 }
 
 const std::string& AuthService::access_token() const {
   return access_token_;
 }
 
 void AuthService::ClearAccessToken() {
   access_token_.clear();
 }
 
 void AuthService::ClearRefreshToken() {
   OnHandleRefreshToken(false);
 }
 
 void AuthService::OnAuthCompleted(const AuthStatusCallback& callback,
-                                  GDataErrorCode error,
+                                  DriveApiErrorCode error,
                                   const std::string& access_token) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (error == HTTP_SUCCESS) {
     access_token_ = access_token;
   } else if (error == HTTP_UNAUTHORIZED) {
     // Refreshing access token using the refresh token is failed with 401 error
     // (HTTP_UNAUTHORIZED). This means the current refresh token is invalid for
     // Drive, hence we clear the refresh token here to make HasRefreshToken()
@@ skipping 28 matching lines @@
 void AuthService::OnHandleRefreshToken(bool has_refresh_token) {
   access_token_.clear();
   has_refresh_token_ = has_refresh_token;
 
   FOR_EACH_OBSERVER(AuthServiceObserver,
                     observers_,
                     OnOAuth2RefreshTokenChanged());
 }
 
 }  // namespace google_apis