When the user signs in, make sure to set cookies on all reachable google

google_apis/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 "google_apis/gaia/gaia_auth_fetcher.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 168 matching lines @@
       client_login_gurl_(GaiaUrls::GetInstance()->client_login_url()),
       issue_auth_token_gurl_(GaiaUrls::GetInstance()->issue_auth_token_url()),
       oauth2_token_gurl_(GaiaUrls::GetInstance()->oauth2_token_url()),
       oauth2_revoke_gurl_(GaiaUrls::GetInstance()->oauth2_revoke_url()),
       get_user_info_gurl_(GaiaUrls::GetInstance()->get_user_info_url()),
       merge_session_gurl_(GaiaUrls::GetInstance()->merge_session_url()),
       uberauth_token_gurl_(GaiaUrls::GetInstance()->oauth1_login_url().Resolve(
           base::StringPrintf(kUberAuthTokenURLFormat, source.c_str()))),
       oauth_login_gurl_(GaiaUrls::GetInstance()->oauth1_login_url()),
       list_accounts_gurl_(GaiaUrls::GetInstance()->list_accounts_url()),
+      get_check_connection_info_url_(
+          GaiaUrls::GetInstance()->get_check_connection_info_url()),
       client_login_to_oauth2_gurl_(
           GaiaUrls::GetInstance()->client_login_to_oauth2_url()),
       fetch_pending_(false) {}
 
 GaiaAuthFetcher::~GaiaAuthFetcher() {}
 
 bool GaiaAuthFetcher::HasPendingFetch() {
   return fetch_pending_;
 }
 
@@ skipping 143 matching lines @@
 
 // static
 std::string GaiaAuthFetcher::MakeGetUserInfoBody(const std::string& lsid) {
   std::string encoded_lsid = net::EscapeUrlEncodedData(lsid, true);
   return base::StringPrintf(kGetUserInfoFormat, encoded_lsid.c_str());
 }
 
 // static
 std::string GaiaAuthFetcher::MakeMergeSessionBody(
     const std::string& auth_token,
+    const std::string& external_cc_result,
     const std::string& continue_url,
     const std::string& source) {
   std::string encoded_auth_token = net::EscapeUrlEncodedData(auth_token, true);
   std::string encoded_continue_url = net::EscapeUrlEncodedData(continue_url,
                                                                true);
   std::string encoded_source = net::EscapeUrlEncodedData(source, true);
-  return base::StringPrintf(kMergeSessionFormat,
-                            encoded_auth_token.c_str(),
-                            encoded_continue_url.c_str(),
-                            encoded_source.c_str());
+  std::string result = base::StringPrintf(kMergeSessionFormat,
+                                          encoded_auth_token.c_str(),
+                                          encoded_continue_url.c_str(),
+                                          encoded_source.c_str());
+  if (!external_cc_result.empty()) {
+    base::StringAppendF(&result, "&externalCcResult=%s",
+                        net::EscapeUrlEncodedData(
+                            external_cc_result, true).c_str());
+  }
+
+  return result;
 }
 
 // static
 std::string GaiaAuthFetcher::MakeGetAuthCodeHeader(
     const std::string& auth_token) {
   return base::StringPrintf(kAuthHeaderFormat, auth_token.c_str());
 }
 
 // Helper method that extracts tokens from a successful reply.
 // static
@@ skipping 243 matching lines @@
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
                                    std::string(),
                                    get_user_info_gurl_,
                                    kLoadFlagsIgnoreCookies,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
-void GaiaAuthFetcher::StartMergeSession(const std::string& uber_token) {
+void GaiaAuthFetcher::StartMergeSession(const std::string& uber_token,
+                                        const std::string& external_cc_result) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   DVLOG(1) << "Starting MergeSession with uber_token=" << uber_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(uber_token, continue_url, source_);
+  request_body_ = MakeMergeSessionBody(uber_token, external_cc_result,
+      continue_url, source_);
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
                                    std::string(),
                                    merge_session_gurl_,
                                    net::LOAD_NORMAL,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
@@ skipping 38 matching lines @@
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    " ",  // To force an HTTP POST.
                                    "Origin: https://www.google.com",
                                    list_accounts_gurl_,
                                    net::LOAD_NORMAL,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
+void GaiaAuthFetcher::StartGetCheckConnectionInfo() {
+  DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
+
+  fetcher_.reset(CreateGaiaFetcher(getter_,
+                                   std::string(),
+                                   std::string(),
+                                   get_check_connection_info_url_,
+                                   kLoadFlagsIgnoreCookies,
+                                   this));
+  fetch_pending_ = true;
+  fetcher_->Start();
+}
+
 // static
 GoogleServiceAuthError GaiaAuthFetcher::GenerateAuthError(
     const std::string& data,
     const net::URLRequestStatus& status) {
   if (!status.is_success()) {
     if (status.status() == net::URLRequestStatus::CANCELED) {
       return GoogleServiceAuthError(GoogleServiceAuthError::REQUEST_CANCELED);
     }
     DLOG(WARNING) << "Could not reach Google Accounts servers: errno "
                   << status.error();
@@ skipping 176 matching lines @@
     std::string lsid;
     std::string token;
     ParseClientLoginResponse(data, &sid, &lsid, &token);
     consumer_->OnClientLoginSuccess(
         GaiaAuthConsumer::ClientLoginResult(sid, lsid, token, data));
   } else {
     consumer_->OnClientLoginFailure(GenerateAuthError(data, status));
   }
 }
 
+void GaiaAuthFetcher::OnGetCheckConnectionInfoFetched(
+    const std::string& data,
+    const net::URLRequestStatus& status,
+    int response_code) {
+  if (status.is_success() && response_code == net::HTTP_OK) {
+    consumer_->OnGetCheckConnectionInfoSuccess(data);
+  } else {
+    consumer_->OnGetCheckConnectionInfoError(GenerateAuthError(data, status));
+  }
+}
+
 void GaiaAuthFetcher::OnURLFetchComplete(const net::URLFetcher* source) {
   fetch_pending_ = false;
   // 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);
@@ skipping 21 matching lines @@
   } else if (url == merge_session_gurl_) {
     OnMergeSessionFetched(data, status, response_code);
   } else if (url == uberauth_token_gurl_) {
     OnUberAuthTokenFetch(data, status, response_code);
   } else if (url == oauth_login_gurl_) {
     OnOAuthLoginFetched(data, status, response_code);
   } else if (url == oauth2_revoke_gurl_) {
     OnOAuth2RevokeTokenFetched(data, status, response_code);
   } else if (url == list_accounts_gurl_) {
     OnListAccountsFetched(data, status, response_code);
+  } else if (url == get_check_connection_info_url_) {
+    OnGetCheckConnectionInfoFetched(data, status, response_code);
   } else {
     NOTREACHED();
   }
 }
 
 // static
 bool GaiaAuthFetcher::IsSecondFactorSuccess(
     const std::string& alleged_error) {
   return alleged_error.find(kSecondFactor) !=
       std::string::npos;
 }