Initial refactoring complete

chrome/common/net/gaia/gaia_auth_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/common/net/gaia/gaia_auth_fetcher.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 76 matching lines @@
 // TODO(chron): These urls are also in auth_response_handler.h.
 // The URLs for different calls in the Google Accounts programmatic login API.
 const char GaiaAuthFetcher::kClientLoginUrl[] =
     "https://www.google.com/accounts/ClientLogin";
 const char GaiaAuthFetcher::kIssueAuthTokenUrl[] =
     "https://www.google.com/accounts/IssueAuthToken";
 const char GaiaAuthFetcher::kGetUserInfoUrl[] =
     "https://www.google.com/accounts/GetUserInfo";
 
 GaiaAuthFetcher::GaiaAuthFetcher(GaiaAuthConsumer* consumer,
-                                       const std::string& source,
-                                       net::URLRequestContextGetter* getter)
-    : consumer_(consumer),
-      getter_(getter),
-      source_(source),
+                                 const std::string& source,
+                                 net::URLRequestContextGetter* getter)
+    : AuthenticationFetcher(consumer, source, getter),
       client_login_gurl_(kClientLoginUrl),
       issue_auth_token_gurl_(kIssueAuthTokenUrl),
-      get_user_info_gurl_(kGetUserInfoUrl),
-      fetch_pending_(false) {}
+      get_user_info_gurl_(kGetUserInfoUrl) {}
 
 GaiaAuthFetcher::~GaiaAuthFetcher() {}
 
-bool GaiaAuthFetcher::HasPendingFetch() {
-  return fetch_pending_;
-}
-
-void GaiaAuthFetcher::CancelRequest() {
-  fetcher_.reset();
-  fetch_pending_ = false;
-}
-
 // static
 URLFetcher* GaiaAuthFetcher::CreateGaiaFetcher(
     net::URLRequestContextGetter* getter,
     const std::string& body,
     const GURL& gaia_gurl,
     URLFetcher::Delegate* delegate) {
 
   URLFetcher* to_return =
       URLFetcher::Create(0,
                          gaia_gurl,
@@ skipping 40 matching lines @@
                             account_type,
                             source.c_str(),
                             service,
                             encoded_login_token.c_str(),
                             encoded_login_captcha.c_str());
 
 }
 
 // static
 std::string GaiaAuthFetcher::MakeIssueAuthTokenBody(
-    const std::string& sid,
-    const std::string& lsid,
+    const AuthenticationConsumer::AuthenticationResult& credentials,
     const char* const service) {
-  std::string encoded_sid = UrlEncodeString(sid);
-  std::string encoded_lsid = UrlEncodeString(lsid);
+  const GaiaAuthConsumer::ClientLoginResult& cred =
+      static_cast<const GaiaAuthConsumer::ClientLoginResult&>(credentials);
+  std::string encoded_sid = UrlEncodeString(cred.sid);
+  std::string encoded_lsid = UrlEncodeString(cred.lsid);
 
   // All tokens should be session tokens except the gaia auth token.
   bool session = true;
   if (!strcmp(service, GaiaConstants::kGaiaService))
     session = false;
 
   return base::StringPrintf(kIssueAuthTokenFormat,
                             encoded_sid.c_str(),
                             encoded_lsid.c_str(),
                             service,
@@ skipping 49 matching lines @@
     } else if (i->first == kErrorUrlParam) {
       error_url->assign(i->second);
     } else if (i->first == kCaptchaUrlParam) {
       captcha_url->assign(i->second);
     } else if (i->first == kCaptchaTokenParam) {
       captcha_token->assign(i->second);
     }
   }
 }
 
+// virtual
+void GaiaAuthFetcher::StartAuthentication(
+      const std::string& username,
+      const std::string& password,
+      const char* const service,
+      const std::string& login_token,
+      const std::string& login_captcha,
+      HostedAccountsSetting allow_hosted_accounts) {
+  StartClientLogin(username, password, service, login_token, login_captcha,
+                   allow_hosted_accounts);
+}
+
 void GaiaAuthFetcher::StartClientLogin(
     const std::string& username,
     const std::string& password,
     const char* const service,
     const std::string& login_token,
     const std::string& login_captcha,
     HostedAccountsSetting allow_hosted_accounts) {
 
-  DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
+  DCHECK(!HasPendingFetch()) << "Tried to fetch two things at once!";
 
   // This class is thread agnostic, so be sure to call this only on the
   // same thread each time.
   VLOG(1) << "Starting new ClientLogin fetch for:" << username;
 
   // Must outlive fetcher_.
   request_body_ = MakeClientLoginBody(username,
                                       password,
                                       source_,
                                       service,
                                       login_token,
                                       login_captcha,
                                       allow_hosted_accounts);
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
                                    client_login_gurl_,
                                    this));
-  fetch_pending_ = true;
+  SetPending();
   fetcher_->Start();
 }
 
-void GaiaAuthFetcher::StartIssueAuthToken(const std::string& sid,
-                                          const std::string& lsid,
-                                          const char* const service) {
+void GaiaAuthFetcher::StartIssueAuthToken(
+    const AuthenticationConsumer::AuthenticationResult& credentials,
+    const char* const service) {
 
-  DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
+  DCHECK(!HasPendingFetch()) << "Tried to fetch two things at once!";
 
   VLOG(1) << "Starting IssueAuthToken for: " << service;
   requested_service_ = service;
-  request_body_ = MakeIssueAuthTokenBody(sid, lsid, service);
+  request_body_ = MakeIssueAuthTokenBody(credentials, service);
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
                                    issue_auth_token_gurl_,
                                    this));
-  fetch_pending_ = true;
+  SetPending();
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartGetUserInfo(const std::string& lsid,
                                        const std::string& info_key) {
-  DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
+  DCHECK(!HasPendingFetch()) << "Tried to fetch two things at once!";
 
   VLOG(1) << "Starting GetUserInfo for lsid=" << lsid;
   request_body_ = MakeGetUserInfoBody(lsid);
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
                                    get_user_info_gurl_,
                                    this));
-  fetch_pending_ = true;
+  SetPending();
   requested_info_key_ = info_key;
   fetcher_->Start();
 }
 
 // static
 GoogleServiceAuthError GaiaAuthFetcher::GenerateAuthError(
     const std::string& data,
     const net::URLRequestStatus& status) {
 
   if (!status.is_success()) {
@@ skipping 37 matching lines @@
 
     LOG(WARNING) << "Incomprehensible response from Google Accounts servers.";
     return GoogleServiceAuthError(
         GoogleServiceAuthError::SERVICE_UNAVAILABLE);
   }
 
   NOTREACHED();
   return GoogleServiceAuthError(GoogleServiceAuthError::SERVICE_UNAVAILABLE);
 }
 
+void GaiaAuthFetcher::OnAuthenticationFetched(
+    const std::string& data,
+    const net::URLRequestStatus& status,
+    int response_code) {
+  OnClientLoginFetched(data, status, response_code);
+}
+
 void GaiaAuthFetcher::OnClientLoginFetched(const std::string& data,
                                            const net::URLRequestStatus& status,
                                            int response_code) {
 
   if (status.is_success() && response_code == RC_REQUEST_OK) {
     VLOG(1) << "ClientLogin successful!";
     std::string sid;
     std::string lsid;
     std::string token;
     ParseClientLoginResponse(data, &sid, &lsid, &token);
-    consumer_->OnClientLoginSuccess(
+    consumer_->OnAuthenticationSuccess(
         GaiaAuthConsumer::ClientLoginResult(sid, lsid, token, data));
   } else {
-    consumer_->OnClientLoginFailure(GenerateAuthError(data, status));
+    // consumer_->OnClientLoginFailure(GenerateAuthError(data, status));
+    consumer_->OnAuthenticationFailure(GenerateAuthError(data, status));
   }
 }
 
 void GaiaAuthFetcher::OnIssueAuthTokenFetched(
     const std::string& data,
     const net::URLRequestStatus& status,
     int response_code) {
   if (status.is_success() && response_code == RC_REQUEST_OK) {
     // Only the bare token is returned in the body of this Gaia call
     // without any padding.
-    consumer_->OnIssueAuthTokenSuccess(requested_service_, data);
+    consumer_->OnIssueTokenSuccess(requested_service_, data);
   } else {
-    consumer_->OnIssueAuthTokenFailure(requested_service_,
+    consumer_->OnIssueTokenFailure(requested_service_,
         GenerateAuthError(data, status));
   }
 }
 
+// virtual
+void GaiaAuthFetcher::OnIssueTokenFetched(const std::string& data,
+                                          const net::URLRequestStatus& status,
+                                          int response_code) {
+  OnIssueAuthTokenFetched(data, status, response_code);
+}
+
 void GaiaAuthFetcher::OnGetUserInfoFetched(
     const std::string& data,
     const net::URLRequestStatus& status,
     int response_code) {
   using std::vector;
   using std::string;
   using std::pair;
 
   if (status.is_success() && response_code == RC_REQUEST_OK) {
     vector<pair<string, string> > tokens;
@@ skipping 10 matching lines @@
     consumer_->OnGetUserInfoFailure(GenerateAuthError(data, status));
   }
 }
 
 void GaiaAuthFetcher::OnURLFetchComplete(const URLFetcher* source,
                                          const GURL& url,
                                          const net::URLRequestStatus& status,
                                          int response_code,
                                          const ResponseCookies& cookies,
                                          const std::string& data) {
-  fetch_pending_ = false;
+  ClearPending();
   if (url == client_login_gurl_) {
     OnClientLoginFetched(data, status, response_code);
   } else if (url == issue_auth_token_gurl_) {
     OnIssueAuthTokenFetched(data, status, response_code);
   } else if (url == get_user_info_gurl_) {
     OnGetUserInfoFetched(data, status, response_code);
   } else {
     NOTREACHED();
   }
 }
 
 // static
 bool GaiaAuthFetcher::IsSecondFactorSuccess(
     const std::string& alleged_error) {
   return alleged_error.find(kSecondFactor) !=
       std::string::npos;
 }