Changes to the GAIA auth fetching to support one-click login.

chrome/common/net/gaia/gaia_auth_fetcher.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/common/net/gaia/gaia_auth_fetcher.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/json/json_reader.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/common/net/gaia/gaia_auth_consumer.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/net/gaia/gaia_urls.h"
 #include "chrome/common/net/gaia/google_service_auth_error.h"
 #include "content/public/common/url_fetcher.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 
 namespace {
+const int kLoadFlagsIgnoreCookies = net::LOAD_DO_NOT_SEND_COOKIES |
+                                    net::LOAD_DO_NOT_SAVE_COOKIES;
+
 static bool CookiePartsContains(const std::vector<std::string>& parts,
                                 const char* part) {
   return std::find(parts.begin(), parts.end(), part) != parts.end();
 }
 }  // namespace
 
 // TODO(chron): Add sourceless version of this formatter.
 // static
 const char GaiaAuthFetcher::kClientLoginFormat[] =
     "Email=%s&"
@@ skipping 102 matching lines @@
 const int GaiaAuthFetcher::kClientLoginToOAuth2CookiePartCodePrefixLength =
     arraysize(GaiaAuthFetcher::kClientLoginToOAuth2CookiePartCodePrefix) - 1;
 // static
 const char GaiaAuthFetcher::kOAuth2RefreshTokenKey[] = "refresh_token";
 // static
 const char GaiaAuthFetcher::kOAuth2AccessTokenKey[] = "access_token";
 // static
 const char GaiaAuthFetcher::kOAuth2ExpiresInKey[] = "expires_in";
 
 GaiaAuthFetcher::GaiaAuthFetcher(GaiaAuthConsumer* consumer,
-                                       const std::string& source,
-                                       net::URLRequestContextGetter* getter)
+                                 const std::string& source,
+                                 net::URLRequestContextGetter* getter)
     : consumer_(consumer),
       getter_(getter),
       source_(source),
       client_login_gurl_(GaiaUrls::GetInstance()->client_login_url()),
       issue_auth_token_gurl_(GaiaUrls::GetInstance()->issue_auth_token_url()),
       client_login_to_oauth2_gurl_(
           GaiaUrls::GetInstance()->client_login_to_oauth2_url()),
       oauth2_token_gurl_(GaiaUrls::GetInstance()->oauth2_token_url()),
       get_user_info_gurl_(GaiaUrls::GetInstance()->get_user_info_url()),
       token_auth_gurl_(GaiaUrls::GetInstance()->token_auth_url()),
@@ skipping 12 matching lines @@
   fetcher_.reset();
   fetch_pending_ = false;
 }
 
 // static
 content::URLFetcher* GaiaAuthFetcher::CreateGaiaFetcher(
     net::URLRequestContextGetter* getter,
     const std::string& body,
     const std::string& headers,
     const GURL& gaia_gurl,
-    bool use_cookies,
+    int load_flags,
     content::URLFetcherDelegate* delegate) {
   content::URLFetcher* to_return = content::URLFetcher::Create(
       0, gaia_gurl,
       body == "" ? content::URLFetcher::GET : content::URLFetcher::POST,
       delegate);
   to_return->SetRequestContext(getter);
   to_return->SetUploadData("application/x-www-form-urlencoded", body);
 
   // The Gaia token exchange requests do not require any cookie-based
   // identification as part of requests.  We suppress sending any cookies to
   // maintain a separation between the user's browsing and Chrome's internal
   // services.  Where such mixing is desired (MergeSession), it will be done
   // explicitly.
-  if (!use_cookies) {
-    to_return->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
-                            net::LOAD_DO_NOT_SAVE_COOKIES);
-  }
+  to_return->SetLoadFlags(load_flags);
+
   if (!headers.empty())
     to_return->SetExtraRequestHeaders(headers);
 
   return to_return;
 }
 
 // static
 std::string GaiaAuthFetcher::MakeClientLoginBody(
     const std::string& username,
     const std::string& password,
@@ skipping 258 matching lines @@
                                       password,
                                       source_,
                                       service,
                                       login_token,
                                       login_captcha,
                                       allow_hosted_accounts);
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
                                    "",
                                    client_login_gurl_,
-                                   false,
+                                   kLoadFlagsIgnoreCookies,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartIssueAuthToken(const std::string& sid,
                                           const std::string& lsid,
                                           const char* const service) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   DVLOG(1) << "Starting IssueAuthToken for: " << service;
   requested_service_ = service;
   request_body_ = MakeIssueAuthTokenBody(sid, lsid, service);
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
                                    "",
                                    issue_auth_token_gurl_,
-                                   false,
+                                   kLoadFlagsIgnoreCookies,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartOAuthLoginTokenFetch(
     const std::string& auth_token) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   DVLOG(1) << "Starting OAuth login token fetch";
   request_body_ = MakeGetAuthCodeBody();
+
+  // If no auth_token is given, then make sure to use the cookie jar with this
+  // request.  Otherwise the token contains all the necessary information and
+  // the cookie jar should not be touched.
+  int load_flags = net::LOAD_NORMAL;
+  std::string auth_code_header = "";
+
+  if (!auth_token.empty()) {
+    load_flags = kLoadFlagsIgnoreCookies;
+    auth_code_header = MakeGetAuthCodeHeader(auth_token);
+  }
+
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
-                                   MakeGetAuthCodeHeader(auth_token),
+                                   auth_code_header,
                                    client_login_to_oauth2_gurl_,
-                                   false,
+                                   load_flags,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartGetUserInfo(const std::string& lsid) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   DVLOG(1) << "Starting GetUserInfo for lsid=" << lsid;
   request_body_ = MakeGetUserInfoBody(lsid);
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
                                    "",
                                    get_user_info_gurl_,
-                                   false,
+                                   kLoadFlagsIgnoreCookies,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartTokenAuth(const std::string& auth_token) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   DVLOG(1) << "Starting TokenAuth with auth_token=" << auth_token;
 
   // The continue URL is a required parameter of the TokenAuth API, but in this
   // case we don't actually need or want to navigate to it.  Setting it to
   // an arbitrary Google URL.
   std::string continue_url("http://www.google.com");
   request_body_ = MakeTokenAuthBody(auth_token, continue_url, source_);
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
                                    "",
                                    token_auth_gurl_,
-                                   false,
+                                   kLoadFlagsIgnoreCookies,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartMergeSession(const std::string& auth_token) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   DVLOG(1) << "Starting MergeSession with auth_token=" << auth_token;
 
   // The continue URL is a required parameter of the MergeSession API, but in
   // this case we don't actually need or want to navigate to it.  Setting it to
   // an arbitrary Google URL.
   //
   // In order for the new session to be merged correctly, the server needs to
   // know what sessions already exist in the browser.  The fetcher needs to be
   // created such that it sends the cookies with the request, which is
   // different from all other requests the fetcher can make.
   std::string continue_url("http://www.google.com");
   request_body_ = MakeMergeSessionBody(auth_token, continue_url, source_);
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
                                    "",
                                    merge_session_gurl_,
-                                   true,
+                                   net::LOAD_NORMAL,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 // static
 void GaiaAuthFetcher::StartUberAuthTokenFetch(const std::string& access_token) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   DVLOG(1) << "Starting StartUberAuthTokenFetch with access_token="
            << access_token;
   std::string authentication_header =
       base::StringPrintf(kOAuthHeaderFormat, access_token.c_str());
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    "",
                                    authentication_header,
                                    uberauth_token_gurl_,
-                                   false,
+                                   kLoadFlagsIgnoreCookies,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 // static
 GoogleServiceAuthError GaiaAuthFetcher::GenerateAuthError(
     const std::string& data,
     const net::URLRequestStatus& status) {
   if (!status.is_success()) {
@@ skipping 144 matching lines @@
 
 void GaiaAuthFetcher::StartOAuth2TokenPairFetch(const std::string& auth_code) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   DVLOG(1) << "Starting OAuth token pair fetch";
   request_body_ = MakeGetTokenPairBody(auth_code);
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
                                    "",
                                    oauth2_token_gurl_,
-                                   false,
+                                   kLoadFlagsIgnoreCookies,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::OnOAuth2TokenPairFetched(
     const std::string& data,
     const net::URLRequestStatus& status,
     int response_code) {
   if (status.is_success() && response_code == net::HTTP_OK) {
@@ skipping 21 matching lines @@
     std::vector<std::pair<std::string, std::string> >::iterator i;
     for (i = tokens.begin(); i != tokens.end(); ++i) {
       matches[i->first] = i->second;
     }
     consumer_->OnGetUserInfoSuccess(matches);
   } else {
     consumer_->OnGetUserInfoFailure(GenerateAuthError(data, status));
   }
 }
 
-void GaiaAuthFetcher::OnTokenAuthFetched(const std::string& data,
+void GaiaAuthFetcher::OnTokenAuthFetched(const net::ResponseCookies& cookies,
+                                         const std::string& data,
                                          const net::URLRequestStatus& status,
                                          int response_code) {
   if (status.is_success() && response_code == net::HTTP_OK) {
-    consumer_->OnTokenAuthSuccess(data);
+    consumer_->OnTokenAuthSuccess(cookies, data);
   } else {
     consumer_->OnTokenAuthFailure(GenerateAuthError(data, status));
   }
 }
 
 void GaiaAuthFetcher::OnMergeSessionFetched(const std::string& data,
                                             const net::URLRequestStatus& status,
                                             int response_code) {
   if (status.is_success() && response_code == net::HTTP_OK) {
     consumer_->OnMergeSessionSuccess(data);
   } else {
     consumer_->OnMergeSessionFailure(GenerateAuthError(data, status));
   }
 }
 
 void GaiaAuthFetcher::OnUberAuthTokenFetch(const std::string& data,
                                            const net::URLRequestStatus& status,
                                            int response_code) {
   if (status.is_success() && response_code == net::HTTP_OK) {
     consumer_->OnUberAuthTokenSuccess(data);
   } else {
     consumer_->OnUberAuthTokenFailure(GenerateAuthError(data, status));
   }
 }
 
 void GaiaAuthFetcher::OnURLFetchComplete(const content::URLFetcher* source) {
   fetch_pending_ = false;
-  const GURL& url = source->GetURL();
+  // Some of the GAIA requests perform redirects, which results in the final
+  // URL of the fetcher not being the original URL requested.  Therefore use
+  // the original URL when determining which OnXXX function to call.
+  const GURL& url = source->GetOriginalURL();
   const net::URLRequestStatus& status = source->GetStatus();
   int response_code = source->GetResponseCode();
   std::string data;
   source->GetResponseAsString(&data);
   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 == client_login_to_oauth2_gurl_) {
     OnClientLoginToOAuth2Fetched(
         data, source->GetCookies(), status, response_code);
   } else if (url == oauth2_token_gurl_) {
     OnOAuth2TokenPairFetched(data, status, response_code);
   } else if (url == get_user_info_gurl_) {
     OnGetUserInfoFetched(data, status, response_code);
   } else if (url == token_auth_gurl_) {
-    OnTokenAuthFetched(data, status, response_code);
-  } else if (url == merge_session_gurl_ ||
-      (source && source->GetOriginalURL() == merge_session_gurl_)) {
-    // MergeSession may redirect, so check the original URL of the fetcher.
+    OnTokenAuthFetched(source->GetCookies(), data, status, response_code);
+  } else if (url == merge_session_gurl_) {
     OnMergeSessionFetched(data, status, response_code);
   } else if (url == uberauth_token_gurl_) {
     OnUberAuthTokenFetch(data, status, response_code);
   } else {
     NOTREACHED();
   }
 }
 
 // static
 bool GaiaAuthFetcher::IsSecondFactorSuccess(
     const std::string& alleged_error) {
   return alleged_error.find(kSecondFactor) !=
       std::string::npos;
 }