[ChromeOS] Always fetch oauth cooken when signing in via extension.

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 229 matching lines @@
 
 
 class LoginUtilsImpl : public LoginUtils,
                        public ProfileManagerObserver,
                        public GaiaOAuthConsumer {
  public:
   LoginUtilsImpl()
       : background_view_(NULL),
         pending_requests_(false),
         using_oauth_(false),
+        has_cookies_(false),
         delegate_(NULL) {
   }
 
   virtual void PrepareProfile(
       const std::string& username,
       const std::string& password,
       const GaiaAuthConsumer::ClientLoginResult& credentials,
       bool pending_requests,
       bool using_oauth,
+      bool has_cookies,
       LoginUtils::Delegate* delegate) OVERRIDE;
 
   // Invoked after the tmpfs is successfully mounted.
   // Launches a browser in the incognito mode.
   virtual void CompleteOffTheRecordLogin(const GURL& start_url) OVERRIDE;
 
   // Invoked when the user is logging in for the first time, or is logging in as
   // a guest user.
   virtual void SetFirstLoginPrefs(PrefService* prefs) OVERRIDE;
 
@@ skipping 87 matching lines @@
   void RespectLocalePreference(Profile* pref);
 
   // The current background view.
   chromeos::BackgroundView* background_view_;
 
   std::string username_;
   std::string password_;
   GaiaAuthConsumer::ClientLoginResult credentials_;
   bool pending_requests_;
   bool using_oauth_;
+  bool has_cookies_;
   // Has to be scoped_refptr, see comment for CreateAuthenticator(...).
   scoped_refptr<Authenticator> authenticator_;
   scoped_ptr<GaiaOAuthFetcher> oauth_fetcher_;
   scoped_ptr<PolicyOAuthFetcher> policy_oauth_fetcher_;
   scoped_ptr<OAuthLoginVerifier> oauth_login_verifier_;
 
   // Delegate to be fired when the profile will be prepared.
   LoginUtils::Delegate* delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(LoginUtilsImpl);
@@ skipping 26 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(LoginUtilsWrapper);
 };
 
 void LoginUtilsImpl::PrepareProfile(
     const std::string& username,
     const std::string& password,
     const GaiaAuthConsumer::ClientLoginResult& credentials,
     bool pending_requests,
     bool using_oauth,
+    bool has_cookies,
     LoginUtils::Delegate* delegate) {
   BootTimesLoader* btl = BootTimesLoader::Get();
 
   VLOG(1) << "Completing login for " << username;
 
   if (CrosLibrary::Get()->EnsureLoaded()) {
     btl->AddLoginTimeMarker("StartSession-Start", false);
     CrosLibrary::Get()->GetLoginLibrary()->StartSession(username, "");
     btl->AddLoginTimeMarker("StartSession-End", false);
   }
 
   btl->AddLoginTimeMarker("UserLoggedIn-Start", false);
   UserManager::Get()->UserLoggedIn(username);
   btl->AddLoginTimeMarker("UserLoggedIn-End", false);
 
   // Switch log file as soon as possible.
   logging::RedirectChromeLogging(*(CommandLine::ForCurrentProcess()));
 
   username_ = username;
   password_ = password;
 
   credentials_ = credentials;
   pending_requests_ = pending_requests;
   using_oauth_ = using_oauth;
+  has_cookies_ = has_cookies;
   delegate_ = delegate;
 
   // The default profile will have been changed because the ProfileManager
   // will process the notification that the UserManager sends out.
   ProfileManager::CreateDefaultProfileAsync(this);
 }
 
 void LoginUtilsImpl::OnProfileCreated(Profile* user_profile, Status status) {
   CHECK(user_profile);
   switch (status) {
@@ skipping 18 matching lines @@
   if (!using_oauth_)
     token_service_for_policy = user_profile->GetTokenService();
   browser_policy_connector->InitializeUserPolicy(username_,
                                                  user_profile->GetPath(),
                                                  token_service_for_policy);
 
   BootTimesLoader* btl = BootTimesLoader::Get();
   btl->AddLoginTimeMarker("UserProfileGotten", false);
 
   if (using_oauth_) {
-    // Transfer cookies for the new user login.
-    if (!pending_requests_) {
+    // Transfer cookies when user signs in using extension.
+    if (has_cookies_) {
       // Transfer cookies from the profile that was used for authentication.
       // This profile contains cookies that auth extension should have already
       // put in place that will ensure that the newly created session is
       // authenticated for the websites that work with the used authentication
       // schema.
       if (!TransferDefaultCookies(authenticator_->authentication_profile(),
                                   user_profile)) {
         LOG(WARNING) << "Cookie transfer from the default profile failed!";
       }
     }
     std::string oauth1_token;
     std::string oauth1_secret;
-    if (ReadOAuth1AccessToken(user_profile, &oauth1_token, &oauth1_secret) ||
-        pending_requests_) {
-      // Verify OAuth access token when we find it in the profile and always if
-      // we are performing parallel authentication.
+    if (!has_cookies_ &&
+        ReadOAuth1AccessToken(user_profile, &oauth1_token, &oauth1_secret)) {
+      // Verify OAuth access token when we find it in the profile and no cookies
+      // available because user is not signing in using extension.
       authenticator_->VerifyOAuth1AccessToken(oauth1_token, oauth1_secret);
     } else {
       // If we don't have it, fetch OAuth1 access token.
       // Use off-the-record profile that was used for this step. It should
       // already contain all needed cookies that will let us skip GAIA's user
       // authentication UI.
       //
       // TODO(rickcam) We should use an isolated App here.
       FetchOAuth1AccessToken(authenticator_->authentication_profile());
     }
@@ skipping 483 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