Shaving parallel authenticator yak to remove unnecessary dependency on this class from OAuth spec...

chrome/browser/net/gaia/gaia_oauth_fetcher.cc

 // Copyright (c) 2011 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/net/gaia/gaia_oauth_fetcher.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 443 matching lines @@
   GURL url(GaiaUrls::GetInstance()->oauth_revoke_token_url());
   fetcher_.reset(CreateGaiaFetcher(getter_, url, request_body_,
                                    request_headers_, false, this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 // static
 GoogleServiceAuthError GaiaOAuthFetcher::GenerateAuthError(
     const std::string& data,
-    const net::URLRequestStatus& status) {
+    const net::URLRequestStatus& status,
+    int response_code) {
   if (!status.is_success()) {
     if (status.status() == net::URLRequestStatus::CANCELED) {
       return GoogleServiceAuthError(GoogleServiceAuthError::REQUEST_CANCELED);
     } else {
       LOG(WARNING) << "Could not reach Google Accounts servers: errno "
                    << status.error();
       return GoogleServiceAuthError::FromConnectionError(status.error());
     }
   } else {
-    LOG(WARNING) << "Unrecognized response from Google Accounts servers.";
+    LOG(WARNING) << "Unrecognized response from Google Accounts servers "
+                 << "code " << response_code << " data " << data;
     return GoogleServiceAuthError(
         GoogleServiceAuthError::SERVICE_UNAVAILABLE);
   }
 
   NOTREACHED();
   return GoogleServiceAuthError(GoogleServiceAuthError::SERVICE_UNAVAILABLE);
 }
 
 void GaiaOAuthFetcher::Observe(int type,
                                const content::NotificationSource& source,
@@ skipping 114 matching lines @@
   if (status.is_success() && response_code == RC_REQUEST_OK) {
     VLOG(1) << "OAuth1 access token fetched.";
     std::string secret;
     std::string token;
     ParseOAuthGetAccessTokenResponse(data, &token, &secret);
     consumer_->OnOAuthGetAccessTokenSuccess(token, secret);
     if (ShouldAutoFetch(OAUTH2_SERVICE_ACCESS_TOKEN))
       StartOAuthWrapBridge(
           token, secret, GaiaConstants::kGaiaOAuthDuration, service_scope_);
   } else {
-    consumer_->OnOAuthGetAccessTokenFailure(GenerateAuthError(data, status));
+    consumer_->OnOAuthGetAccessTokenFailure(GenerateAuthError(data, status,
+                                                              response_code));
   }
 }
 
 void GaiaOAuthFetcher::OnOAuthWrapBridgeFetched(
     const std::string& data,
     const net::URLRequestStatus& status,
     int response_code) {
   if (status.is_success() && response_code == RC_REQUEST_OK) {
     VLOG(1) << "OAuth2 access token fetched.";
     std::string token;
     std::string expires_in;
     ParseOAuthWrapBridgeResponse(data, &token, &expires_in);
     consumer_->OnOAuthWrapBridgeSuccess(service_scope_, token, expires_in);
     if (ShouldAutoFetch(USER_INFO))
       StartUserInfo(token);
   } else {
     consumer_->OnOAuthWrapBridgeFailure(service_scope_,
-                                        GenerateAuthError(data, status));
+                                        GenerateAuthError(data, status,
+                                                          response_code));
   }
 }
 
 void GaiaOAuthFetcher::OnOAuthRevokeTokenFetched(
     const std::string& data,
     const net::URLRequestStatus& status,
     int response_code) {
   if (status.is_success() && response_code == RC_REQUEST_OK) {
     consumer_->OnOAuthRevokeTokenSuccess();
   } else {
     LOG(ERROR) << "Token revocation failure " << response_code << ": " << data;
-    consumer_->OnOAuthRevokeTokenFailure(GenerateAuthError(data, status));
+    consumer_->OnOAuthRevokeTokenFailure(GenerateAuthError(data, status,
+                                                           response_code));
   }
 }
 
 void GaiaOAuthFetcher::OnUserInfoFetched(
     const std::string& data,
     const net::URLRequestStatus& status,
     int response_code) {
   if (status.is_success() && response_code == RC_REQUEST_OK) {
     std::string email;
     ParseUserInfoResponse(data, &email);
     VLOG(1) << "GAIA user info fetched for " << email << ".";
     consumer_->OnUserInfoSuccess(email);
   } else {
-    consumer_->OnUserInfoFailure(GenerateAuthError(data, status));
+    consumer_->OnUserInfoFailure(GenerateAuthError(data, status,
+                                                   response_code));
   }
 }
 
 void GaiaOAuthFetcher::OnURLFetchComplete(const content::URLFetcher* source) {
   // Keep |fetcher_| around to avoid invalidating its |status| (accessed below).
   scoped_ptr<content::URLFetcher> current_fetcher(fetcher_.release());
   fetch_pending_ = false;
   GaiaUrls* gaia_urls = GaiaUrls::GetInstance();
   GURL url = source->GetURL();
   std::string data;
@@ skipping 15 matching lines @@
                              true)) {
     OnOAuthRevokeTokenFetched(data, status, response_code);
   } else {
     NOTREACHED();
   }
 }
 
 bool GaiaOAuthFetcher::ShouldAutoFetch(AutoFetchLimit fetch_step) {
   return fetch_step <= auto_fetch_limit_;
 }