Fixed GAIA session cookie fetching.

chrome/browser/chromeos/login/login_utils.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/browser/chromeos/login/login_utils.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 32 matching lines @@
 #include "chrome/browser/net/preconnect.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/prefs/pref_member.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/ui/browser_init.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/logging_chrome.h"
+#include "chrome/common/net/gaia/gaia_auth_consumer.h"
+#include "chrome/common/net/gaia/gaia_auth_fetcher.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/net/gaia/gaia_urls.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/browser_thread.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/cookie_store.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
@@ skipping 30 matching lines @@
 class StartSyncOnUIThreadTask : public Task {
  public:
   StartSyncOnUIThreadTask(
       const GaiaAuthConsumer::ClientLoginResult& credentials)
       : credentials_(credentials) {}
   virtual ~StartSyncOnUIThreadTask() {}
 
   // Task override.
   virtual void Run() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
+    LoginUtils::Get()->FetchCookies(ProfileManager::GetDefaultProfile(),
+                                    credentials_);
     LoginUtils::Get()->StartSync(ProfileManager::GetDefaultProfile(),
                                    credentials_);
   }
 
  private:
-  Profile* user_profile_;
   GaiaAuthConsumer::ClientLoginResult credentials_;
 };
 
 // Transfers initial set of Profile cookies form the default profile.
 class TransferDefaultCookiesOnIOThreadTask : public Task {
  public:
   TransferDefaultCookiesOnIOThreadTask(
       net::URLRequestContextGetter* auth_context, Profile* new_profile,
       net::URLRequestContextGetter* new_context)
           : auth_context_(auth_context),
@@ skipping 94 matching lines @@
 
  private:
   GaiaOAuthFetcher oauth_fetcher_;
   std::string oauth1_token_;
   std::string oauth1_secret_;
   std::string username_;
 
   DISALLOW_COPY_AND_ASSIGN(OAuthLoginVerifier);
 };
 
+// Verifies OAuth1 access token by performing OAuthLogin.
+class UserSessionCookieFetcher : public GaiaAuthConsumer {
+ public:
+  explicit UserSessionCookieFetcher(Profile* user_profile)
+      : gaia_fetcher_(this,
+                      std::string(GaiaConstants::kChromeOSSource),
+                      user_profile->GetRequestContext()) {
+  }
+  virtual ~UserSessionCookieFetcher() {}
+
+  void Start(const GaiaAuthConsumer::ClientLoginResult& credentials) {
+    gaia_fetcher_.StartIssueAuthToken(credentials.sid, credentials.lsid,
+                                      GaiaConstants::kGaiaService);
+  }
+
+  // GaiaAuthConsumer overrides.
+  virtual void OnIssueAuthTokenSuccess(const std::string& service,
+                                       const std::string& auth_token) OVERRIDE {
+    gaia_fetcher_.StartMergeSession(auth_token);
+  }
+
+  virtual void OnIssueAuthTokenFailure(const std::string& service,
+      const GoogleServiceAuthError& error) OVERRIDE {
+    LOG(WARNING) << "Failed IssueAuthToken request,"
+                 << " error.state=" << error.state();
+    HandlerGaiaAuthError(error);
+    delete this;
+  }
+
+  virtual void OnMergeSessionSuccess(const std::string& data) OVERRIDE {
+    VLOG(1) << "MergeSession successful.";
+    delete this;
+  }
+
+  virtual void OnMergeSessionFailure(
+      const GoogleServiceAuthError& error) OVERRIDE {
+    LOG(WARNING) << "Failed MergeSession request,"
+                 << " error.state=" << error.state();
+    HandlerGaiaAuthError(error);
+    delete this;
+  }
+
+ private:
+  void HandlerGaiaAuthError(const GoogleServiceAuthError& error) {
+    // Mark this account's login state as offline if we encountered a network
+    // error. That will make us verify user OAuth token and try to fetch session
+    // cookies again once we detect that the machine comes online.
+    if (error.state() == GoogleServiceAuthError::CONNECTION_FAILED)
+      UserManager::Get()->set_offline_login(true);
+  }
+
+  GaiaAuthFetcher gaia_fetcher_;
+  DISALLOW_COPY_AND_ASSIGN(UserSessionCookieFetcher);
+};
+
+
 // Fetches an OAuth token and initializes user policy with it.
 class PolicyOAuthFetcher : public GaiaOAuthConsumer {
  public:
   PolicyOAuthFetcher(Profile* profile,
                      const std::string& oauth1_token,
                      const std::string& oauth1_secret)
       : oauth_fetcher_(this,
                        profile->GetRequestContext(),
                        profile,
                        kServiceScopeChromeOSDeviceManagement),
@@ skipping 389 matching lines @@
                                             auth_profile->GetRequestContext(),
                                             auth_profile,
                                             kServiceScopeChromeOS));
   // Let's first get the Oauth request token and OAuth1 token+secret.
   // One we get that, we will kick off individial requests for OAuth2 tokens for
   // all our services.
   oauth_fetcher_->SetAutoFetchLimit(GaiaOAuthFetcher::OAUTH1_ALL_ACCESS_TOKEN);
   oauth_fetcher_->StartGetOAuthTokenRequest();
 }
 
-void LoginUtilsImpl::FetchCookies(
-    Profile* profile,
+void LoginUtilsImpl::FetchCookies(Profile* user_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);
+  if (!using_oauth_) {
+    // 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(user_profile);
+    cf->AttemptFetch(credentials.data);
+  } else {
+    UserSessionCookieFetcher* cf =
+        new UserSessionCookieFetcher(user_profile);
+    cf->Start(credentials);
+  }
 }
 
 void LoginUtilsImpl::StartTokenServices(Profile* user_profile) {
   std::string oauth1_token;
   std::string oauth1_secret;
   if (!ReadOAuth1AccessToken(user_profile, &oauth1_token, &oauth1_secret))
     return;
 
   FetchSecondaryTokens(user_profile->GetOffTheRecordProfile(), oauth1_token,
                        oauth1_secret);
@@ skipping 419 matching lines @@
   // Mark login host for deletion after browser starts.  This
   // guarantees that the message loop will be referenced by the
   // browser before it is dereferenced by the login host.
   if (login_host) {
     login_host->OnSessionStart();
     login_host = NULL;
   }
 }
 
 }  // namespace chromeos