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

google_apis/gaia/gaia_auth_fetcher.h

 // 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.
 
 #ifndef GOOGLE_APIS_GAIA_GAIA_AUTH_FETCHER_H_
 #define GOOGLE_APIS_GAIA_GAIA_AUTH_FETCHER_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 130 matching lines @@
   // called on the consumer on the original thread.
   void StartGetUserInfo(const std::string& lsid);
 
   // Start a MergeSession request to pre-login the user with the given
   // credentials.
   //
   // Start a MergeSession request to fill the browsing cookie jar with
   // credentials represented by the account whose uber-auth token is
   // |uber_token|.  This method will modify the cookies of the current profile.
   //
+  // The |external_cc_result| string can specify the result of connetion checks
+  // for various google properties, and MergeSession will set cookies on those
+  // properties too if appropriate.  See StartGetCheckConnectionInfo() for
+  // details.  The string is a comma separated list of token/result pairs, where
+  // token and result are separated by a colon.  This string may be empty, in
+  // which case no specific handling is performed.
+  //
   // Either OnMergeSessionSuccess or OnMergeSessionFailure will be
   // called on the consumer on the original thread.
-  void StartMergeSession(const std::string& uber_token);
+  void StartMergeSession(const std::string& uber_token,
+                         const std::string& external_cc_result);
 
   // Start a request to exchange an OAuthLogin-scoped oauth2 access token for an
   // uber-auth token.  The returned token can be used with the method
   // StartMergeSession().
   //
   // Either OnUberAuthTokenSuccess or OnUberAuthTokenFailure will be
   // called on the consumer on the original thread.
   void StartTokenFetchForUberAuthExchange(const std::string& access_token);
 
   // Start a request to exchange an OAuthLogin-scoped oauth2 access token for a
   // ClientLogin-style service tokens.  The response to this request is the
   // same as the response to a ClientLogin request, except that captcha
   // challenges are never issued.
   //
   // Either OnClientLoginSuccess or OnClientLoginFailure will be
   // called on the consumer on the original thread. If |service| is empty,
   // the call will attempt to fetch uber auth token.
   void StartOAuthLogin(const std::string& access_token,
                        const std::string& service);
 
   // Starts a request to list the accounts in the GAIA cookie.
   void StartListAccounts();
 
+  // Starts a request to get the list of URLs to check for connection info.
+  // Returns token/URL pairs to check, and the resulting status can be given to
+  // /MergeSession requests.
+  void StartGetCheckConnectionInfo();
+
   // Implementation of net::URLFetcherDelegate
   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
 
   // StartClientLogin been called && results not back yet?
   bool HasPendingFetch();
 
   // Stop any URL fetches in progress.
   void CancelRequest();
 
   // From a URLFetcher result, generate an appropriate error.
@@ skipping 99 matching lines @@
                              int response_code);
 
   void OnUberAuthTokenFetch(const std::string& data,
                             const net::URLRequestStatus& status,
                             int response_code);
 
   void OnOAuthLoginFetched(const std::string& data,
                            const net::URLRequestStatus& status,
                            int response_code);
 
+  void OnGetCheckConnectionInfoFetched(const std::string& data,
+                                       const net::URLRequestStatus& status,
+                                       int response_code);
+
   // Tokenize the results of a ClientLogin fetch.
   static void ParseClientLoginResponse(const std::string& data,
                                        std::string* sid,
                                        std::string* lsid,
                                        std::string* token);
 
   static void ParseClientLoginFailure(const std::string& data,
                                       std::string* error,
                                       std::string* error_url,
                                       std::string* captcha_url,
@@ skipping 29 matching lines @@
   // Given auth code, create body to get OAuth2 token pair.
   static std::string MakeGetTokenPairBody(const std::string& auth_code);
   // Given an OAuth2 token, create body to revoke the token.
   std::string MakeRevokeTokenBody(const std::string& auth_token);
   // Supply the lsid returned from ClientLogin in order to fetch
   // user information.
   static std::string MakeGetUserInfoBody(const std::string& lsid);
 
   // Supply the authentication token returned from StartIssueAuthToken.
   static std::string MakeMergeSessionBody(const std::string& auth_token,
-                                       const std::string& continue_url,
-                                       const std::string& source);
+                                          const std::string& external_cc_result,
+                                          const std::string& continue_url,
+                                          const std::string& source);
 
   static std::string MakeGetAuthCodeHeader(const std::string& auth_token);
 
   static std::string MakeOAuthLoginBody(const std::string& service,
                                         const std::string& source);
 
   // Create a fetcher usable for making any Gaia request.  |body| is used
   // as the body of the POST request sent to GAIA.  Any strings listed in
   // |headers| are added as extra HTTP headers in the request.
   //
@@ skipping 20 matching lines @@
   std::string source_;
   const GURL client_login_gurl_;
   const GURL issue_auth_token_gurl_;
   const GURL oauth2_token_gurl_;
   const GURL oauth2_revoke_gurl_;
   const GURL get_user_info_gurl_;
   const GURL merge_session_gurl_;
   const GURL uberauth_token_gurl_;
   const GURL oauth_login_gurl_;
   const GURL list_accounts_gurl_;
+  const GURL get_check_connection_info_url_;
 
   // While a fetch is going on:
   scoped_ptr<net::URLFetcher> fetcher_;
   GURL client_login_to_oauth2_gurl_;
   std::string request_body_;
   std::string requested_service_; // Currently tracked for IssueAuthToken only.
   bool fetch_pending_;
 
   friend class GaiaAuthFetcherTest;
   FRIEND_TEST_ALL_PREFIXES(GaiaAuthFetcherTest, CaptchaParse);
@@ skipping 10 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(GaiaAuthFetcherTest, ParseOAuth2TokenPairResponse);
   FRIEND_TEST_ALL_PREFIXES(GaiaAuthFetcherTest, ClientOAuthSuccess);
   FRIEND_TEST_ALL_PREFIXES(GaiaAuthFetcherTest, ClientOAuthWithQuote);
   FRIEND_TEST_ALL_PREFIXES(GaiaAuthFetcherTest, ClientOAuthChallengeSuccess);
   FRIEND_TEST_ALL_PREFIXES(GaiaAuthFetcherTest, ClientOAuthChallengeQuote);
 
   DISALLOW_COPY_AND_ASSIGN(GaiaAuthFetcher);
 };
 
 #endif  // GOOGLE_APIS_GAIA_GAIA_AUTH_FETCHER_H_