When a user logs into sync, the appropriate cookies are retrieved so that

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 30 matching lines @@
     "logincaptcha=%s";
 // static
 const char GaiaAuthFetcher::kIssueAuthTokenFormat[] =
     "SID=%s&"
     "LSID=%s&"
     "service=%s&"
     "Session=%s";
 // static
 const char GaiaAuthFetcher::kGetUserInfoFormat[] =
     "LSID=%s";
+// static
+const char GaiaAuthFetcher::kTokenAuthFormat[] =
+    "auth=%s&"
+    "continue=%s&"
+    "source=%s";
 
 // static
 const char GaiaAuthFetcher::kAccountDeletedError[] = "AccountDeleted";
 // static
 const char GaiaAuthFetcher::kAccountDisabledError[] = "AccountDisabled";
 // static
 const char GaiaAuthFetcher::kBadAuthenticationError[] = "BadAuthentication";
 // static
 const char GaiaAuthFetcher::kCaptchaError[] = "CaptchaRequired";
 // static
@@ skipping 25 matching lines @@
 const char GaiaAuthFetcher::kSecondFactor[] = "Info=InvalidSecondFactor";
 
 // 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";
+const char GaiaAuthFetcher::kTokenAuthUrl[] =
+    "https://www.google.com/accounts/TokenAuth";
 
 GaiaAuthFetcher::GaiaAuthFetcher(GaiaAuthConsumer* consumer,
                                        const std::string& source,
                                        net::URLRequestContextGetter* getter)
     : consumer_(consumer),
       getter_(getter),
       source_(source),
       client_login_gurl_(kClientLoginUrl),
       issue_auth_token_gurl_(kIssueAuthTokenUrl),
       get_user_info_gurl_(kGetUserInfoUrl),
+      token_auth_gurl_(kTokenAuthUrl),
       fetch_pending_(false) {}
 
 GaiaAuthFetcher::~GaiaAuthFetcher() {}
 
 bool GaiaAuthFetcher::HasPendingFetch() {
   return fetch_pending_;
 }
 
 void GaiaAuthFetcher::CancelRequest() {
   fetcher_.reset();
@@ skipping 77 matching lines @@
                             service,
                             session ? "true" : "false");
 }
 
 // static
 std::string GaiaAuthFetcher::MakeGetUserInfoBody(const std::string& lsid) {
   std::string encoded_lsid = EscapeUrlEncodedData(lsid);
   return base::StringPrintf(kGetUserInfoFormat, encoded_lsid.c_str());
 }
 
+// static
+std::string GaiaAuthFetcher::MakeTokenAuthBody(const std::string& auth_token,
+                                               const std::string& continue_url,
+                                               const std::string& source) {
+  std::string encoded_auth_token = EscapeUrlEncodedData(auth_token);
+  std::string encoded_continue_url = EscapeUrlEncodedData(continue_url);
+  std::string encoded_source = EscapeUrlEncodedData(source);
+  return base::StringPrintf(kTokenAuthFormat,
+                            encoded_auth_token.c_str(),
+                            encoded_continue_url.c_str(),
+                            encoded_source.c_str());
+}
+
 // Helper method that extracts tokens from a successful reply.
 // static
 void GaiaAuthFetcher::ParseClientLoginResponse(const std::string& data,
                                                   std::string* sid,
                                                   std::string* lsid,
                                                   std::string* token) {
   using std::vector;
   using std::pair;
   using std::string;
 
@@ skipping 92 matching lines @@
   request_body_ = MakeGetUserInfoBody(lsid);
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
                                    get_user_info_gurl_,
                                    this));
   fetch_pending_ = true;
   requested_info_key_ = info_key;
   fetcher_->Start();
 }
 
+void GaiaAuthFetcher::StartTokenAuth(const std::string& auth_token) {
+  DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
+
+  VLOG(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_,
+                                   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);
     } else {
       LOG(WARNING) << "Could not reach Google Accounts servers: errno "
           << status.os_error();
@@ skipping 86 matching lines @@
         consumer_->OnGetUserInfoSuccess(i->first, i->second);
         return;
       }
     }
     consumer_->OnGetUserInfoKeyNotFound(requested_info_key_);
   } else {
     consumer_->OnGetUserInfoFailure(GenerateAuthError(data, status));
   }
 }
 
+void GaiaAuthFetcher::OnTokenAuthFetched(const std::string& data,
+                                         const net::URLRequestStatus& status,
+                                         int response_code) {
+  if (status.is_success() && response_code == RC_REQUEST_OK) {
+    consumer_->OnTokenAuthSuccess(data);
+  } else {
+    consumer_->OnTokenAuthFailure(GenerateAuthError(data, status));
+  }
+}
+
 void GaiaAuthFetcher::OnURLFetchComplete(const URLFetcher* source,
                                          const GURL& url,
                                          const net::URLRequestStatus& status,
                                          int response_code,
                                          const net::ResponseCookies& cookies,
                                          const std::string& data) {
   fetch_pending_ = false;
   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 if (url == token_auth_gurl_) {
+    OnTokenAuthFetched(data, status, response_code);
   } else {
     NOTREACHED();
   }
 }
 
 // static
 bool GaiaAuthFetcher::IsSecondFactorSuccess(
     const std::string& alleged_error) {
   return alleged_error.find(kSecondFactor) !=
       std::string::npos;
 }