[cros] Fetch cookies after online authentication is successful.

chrome/browser/chromeos/login/login_utils.cc

 // Copyright (c) 2010 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/browser/chromeos/login/login_utils.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
@@ skipping 89 matching lines @@
  public:
   LoginUtilsImpl()
       : browser_launch_enabled_(true) {
   }
 
   // Invoked after the user has successfully logged in. This launches a browser
   // and does other bookkeeping after logging in.
   virtual void CompleteLogin(
       const std::string& username,
       const std::string& password,
-      const GaiaAuthConsumer::ClientLoginResult& credentials);
+      const GaiaAuthConsumer::ClientLoginResult& credentials,
+      bool pending_requests);
 
   // Invoked after the tmpfs is successfully mounted.
   // Launches a browser in the off the record (incognito) mode.
   virtual void CompleteOffTheRecordLogin(const GURL& start_url);
 
   // Invoked when the user is logging in for the first time, or is logging in as
   // a guest user.
   virtual void SetFirstLoginPrefs(PrefService* prefs);
 
   // Creates and returns the authenticator to use. The caller owns the returned
   // Authenticator and must delete it when done.
   virtual Authenticator* CreateAuthenticator(LoginStatusConsumer* consumer);
 
   // Used to postpone browser launch via DoBrowserLaunch() if some post
   // login screen is to be shown.
   virtual void EnableBrowserLaunch(bool enable);
 
   // Returns if browser launch enabled now or not.
   virtual bool IsBrowserLaunchEnabled() const;
 
   // Warms the url used by authentication.
   virtual void PrewarmAuthentication();
 
+  // Given the credentials try to exchange them for
+  // full-fledged Google authentication cookies.
+  virtual void FetchCookies(
+      Profile* profile,
+      const GaiaAuthConsumer::ClientLoginResult& credentials);
+
+  // Supply credentials for sync and others to use.
+  virtual void FetchTokens(
+      Profile* profile,
+      const GaiaAuthConsumer::ClientLoginResult& credentials);
+
  private:
   // Check user's profile for kApplicationLocale setting.
   void RespectLocalePreference(PrefService* pref);
 
   // Indicates if DoBrowserLaunch will actually launch the browser or not.
   bool browser_launch_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(LoginUtilsImpl);
 };
 
@@ skipping 21 matching lines @@
 
   Lock create_lock_;
   scoped_ptr<LoginUtils> ptr_;
 
   DISALLOW_COPY_AND_ASSIGN(LoginUtilsWrapper);
 };
 
 void LoginUtilsImpl::CompleteLogin(
     const std::string& username,
     const std::string& password,
-    const GaiaAuthConsumer::ClientLoginResult& credentials) {
+    const GaiaAuthConsumer::ClientLoginResult& credentials,
+    bool pending_requests) {
   BootTimesLoader* btl = BootTimesLoader::Get();
 
   VLOG(1) << "Completing login for " << username;
   btl->AddLoginTimeMarker("CompletingLogin", false);
 
   if (CrosLibrary::Get()->EnsureLoaded()) {
     CrosLibrary::Get()->GetLoginLibrary()->StartSession(username, "");
     btl->AddLoginTimeMarker("StartedSession", false);
   }
 
@@ skipping 30 matching lines @@
   // device policy.
   net::ProxyConfigService* proxy_config_service =
       new PrefProxyConfigService(
           profile->GetProxyConfigTracker(),
           new chromeos::ProxyConfigService(
               profile->GetChromeOSProxyConfigServiceImpl()));
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           new ResetDefaultProxyConfigServiceTask(
                               proxy_config_service));
 
-  // Take the credentials passed in and try to exchange them for
-  // full-fledged Google authentication cookies.  This is
-  // best-effort; it's possible that we'll fail due to network
-  // troubles or some such.  Either way, |cf| will call
-  // DoBrowserLaunch on the UI thread when it's done, and then
-  // delete itself.
-  CookieFetcher* cf = new CookieFetcher(profile);
-  cf->AttemptFetch(credentials.data);
-  btl->AddLoginTimeMarker("CookieFetchStarted", false);
+  // Since we're doing parallel authentication, only new user sign in
+  // would perform online auth before calling CompleteLogin.
+  // For existing users there's usually a pending online auth request.
+  // Cookies will be fetched after it's is succeeded.
+  if (!pending_requests) {
+    FetchCookies(profile, credentials);
+  }
 
   // Init extension event routers; this normally happens in browser_main
   // but on Chrome OS it has to be deferred until the user finishes
   // logging in and the profile is not OTR.
   if (profile->GetExtensionsService() &&
       profile->GetExtensionsService()->extensions_enabled()) {
     profile->GetExtensionsService()->InitEventRouters();
   }
   btl->AddLoginTimeMarker("ExtensionsServiceStarted", false);
 
   // Supply credentials for sync and others to use. Load tokens from disk.
   TokenService* token_service = profile->GetTokenService();
   token_service->Initialize(GaiaConstants::kChromeOSSource,
                             profile);
   token_service->LoadTokensFromDB();
-  token_service->UpdateCredentials(credentials);
-  if (token_service->AreCredentialsValid()) {
-    token_service->StartFetchingTokens();
+
+  // For existing users there's usually a pending online auth request.
+  // Tokens will be fetched after it's is succeeded.
+  if (!pending_requests) {
+    FetchTokens(profile, credentials);
   }
   btl->AddLoginTimeMarker("TokensGotten", false);
 
   // Set the CrOS user by getting this constructor run with the
   // user's email on first retrieval.
   profile->GetProfileSyncService(username)->SetPassphrase(password, false);
   btl->AddLoginTimeMarker("SyncStarted", false);
 
   // Attempt to take ownership; this will fail if device is already owned.
   OwnershipService::GetSharedInstance()->StartTakeOwnershipAttempt(
@@ skipping 23 matching lines @@
   // out when we get that done properly.
   // TODO(xiyuan): Remove this once enterprise feature is ready.
   if (EndsWith(username, "@google.com", true)) {
     PrefService* pref_service = profile->GetPrefs();
     pref_service->SetBoolean(prefs::kEnableScreenLock, true);
   }
 
   DoBrowserLaunch(profile);
 }
 
+void LoginUtilsImpl::FetchCookies(
+    Profile* profile,
+    const GaiaAuthConsumer::ClientLoginResult& credentials) {
+  // Take the credentials passed in and try to exchange them for
+  // full-fledged Google authentication cookies.  This is
+  // best-effort; it's possible that we'll fail due to network
+  // troubles or some such.
+  // CookieFetcher will delete itself once done.
+  CookieFetcher* cf = new CookieFetcher(profile);
+  cf->AttemptFetch(credentials.data);
+  BootTimesLoader::Get()->AddLoginTimeMarker("CookieFetchStarted", false);
+}
+
+void LoginUtilsImpl::FetchTokens(
+    Profile* profile,
+    const GaiaAuthConsumer::ClientLoginResult& credentials) {
+  TokenService* token_service = profile->GetTokenService();
+  token_service->UpdateCredentials(credentials);
+  if (token_service->AreCredentialsValid()) {
+    token_service->StartFetchingTokens();
+  }
+}
+
 void LoginUtilsImpl::RespectLocalePreference(PrefService* pref) {
   std::string pref_locale = pref->GetString(prefs::kApplicationLocale);
   if (pref_locale.empty()) {
     // TODO(dilmah): current code will clobber existing setting in case
     // language preference was set via another device
     // but still not synced yet.  Profile is not synced at this point yet.
     pref->SetString(prefs::kApplicationLocale,
                     g_browser_process->GetApplicationLocale());
   } else {
     LanguageSwitchMenu::SwitchLanguage(pref_locale);
@@ skipping 175 matching lines @@
   BrowserInit browser_init;
   int return_code;
   browser_init.LaunchBrowser(*CommandLine::ForCurrentProcess(),
                              profile,
                              FilePath(),
                              true,
                              &return_code);
 }
 
 }  // namespace chromeos