Allow sign in while browser is opened when force-sign-in policy is enabled.

chrome/browser/ui/webui/signin/inline_login_handler_impl.cc

 // Copyright 2013 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/ui/webui/signin/inline_login_handler_impl.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <vector>
@@ skipping 144 matching lines @@
     Profile* profile,
     Profile::CreateStatus create_status,
     const GURL& current_url,
     const std::string& email,
     const std::string& gaia_id,
     const std::string& password,
     const std::string& session_index,
     const std::string& auth_code,
     const std::string& signin_scoped_device_id,
     bool choose_what_to_sync,
-    bool confirm_untrusted_signin)
+    bool confirm_untrusted_signin,
+    bool is_force_sign_in_with_usermanager)
     : gaia_auth_fetcher_(this, GaiaConstants::kChromeSource, getter),
       handler_(handler),
       profile_(profile),
       create_status_(create_status),
       current_url_(current_url),
       email_(email),
       gaia_id_(gaia_id),
       password_(password),
       session_index_(session_index),
       auth_code_(auth_code),
       choose_what_to_sync_(choose_what_to_sync),
-      confirm_untrusted_signin_(confirm_untrusted_signin) {
+      confirm_untrusted_signin_(confirm_untrusted_signin),
+      is_force_sign_in_with_usermanager_(is_force_sign_in_with_usermanager) {
   DCHECK(profile_);
   DCHECK(!email_.empty());
   if (!auth_code_.empty()) {
     gaia_auth_fetcher_.StartAuthCodeForOAuth2TokenExchangeWithDeviceId(
         auth_code, signin_scoped_device_id);
   } else {
     DCHECK(!session_index_.empty());
     gaia_auth_fetcher_.StartCookieForOAuthLoginTokenExchangeWithDeviceId(
         session_index_, signin_scoped_device_id);
   }
 }
 
 InlineSigninHelper::~InlineSigninHelper() {}
 
 void InlineSigninHelper::OnClientOAuthSuccess(const ClientOAuthResult& result) {
-  if (signin::IsForceSigninEnabled()) {
-    // With force sign in enabled, the browser window won't be opened until now.
+  if (is_force_sign_in_with_usermanager_) {
+    // If user sign in in UserManager with force sign in enabled, the browser
+    // window won't be opened until now.
     profiles::OpenBrowserWindowForProfile(
         base::Bind(&InlineSigninHelper::OnClientOAuthSuccessAndBrowserOpened,
                    base::Unretained(this), result),
         true, false, profile_, create_status_);
   } else {
     OnClientOAuthSuccessAndBrowserOpened(result, profile_, create_status_);
   }
 }
 
 void InlineSigninHelper::OnClientOAuthSuccessAndBrowserOpened(
     const ClientOAuthResult& result,
     Profile* profile,
     Profile::CreateStatus status) {
-  if (signin::IsForceSigninEnabled())
+  if (is_force_sign_in_with_usermanager_)
     UnlockProfileAndHideLoginUI(profile_->GetPath(), handler_.get());
   content::WebContents* contents = NULL;
   Browser* browser = NULL;
   if (handler_) {
     contents = handler_->web_ui()->GetWebContents();
     browser = handler_->GetDesktopBrowser();
   }
 
   AboutSigninInternals* about_signin_internals =
       AboutSigninInternalsFactory::GetForProfile(profile_);
@@ skipping 90 matching lines @@
       profile_, browser, gaia_id_, email_, password_, refresh_token,
       profile_mode, start_mode, contents, confirmation_required, current_url,
       continue_url,
       base::Bind(&InlineLoginHandlerImpl::SyncStarterCallback, handler_));
 }
 
 bool InlineSigninHelper::HandleCrossAccountError(
     const std::string& refresh_token,
     OneClickSigninSyncStarter::ConfirmationRequired confirmation_required,
     OneClickSigninSyncStarter::StartSyncMode start_mode) {
-  // With force sign in enabled, cross account sign in will be rejected in the
-  // early stage so there is no need to show the warning page here.
+  // With force sign in enabled, cross account
+  // sign in will be rejected in the early stage so there is no need to show the
+  // warning page here.
   if (signin::IsForceSigninEnabled())
     return false;
 
   std::string last_email =
       profile_->GetPrefs()->GetString(prefs::kGoogleServicesLastUsername);
 
   // TODO(skym): Warn for high risk upgrade scenario, crbug.com/572754.
   if (!IsCrossAccountError(profile_, email_, gaia_id_))
     return false;
 
@@ skipping 307 matching lines @@
     }
     if (!path.empty()) {
       signin_metrics::Reason reason =
           signin::GetSigninReasonForPromoURL(current_url);
       // If we are only reauthenticating a profile in the user manager (and not
       // unlocking it), load the profile and finish the login.
       if (reason == signin_metrics::Reason::REASON_REAUTHENTICATION) {
         FinishCompleteLoginParams params(
             this, partition, current_url, base::FilePath(),
             confirm_untrusted_signin_, email, gaia_id, password, session_index,
-            auth_code, choose_what_to_sync);
+            auth_code, choose_what_to_sync, false);
         ProfileManager::CreateCallback callback =
             base::Bind(&InlineLoginHandlerImpl::FinishCompleteLogin, params);
         profiles::LoadProfileAsync(path, callback);
       } else {
         // Otherwise, switch to the profile and finish the login. Pass the
         // profile path so it can be marked as unlocked. Don't pass a handler
         // pointer since it will be destroyed before the callback runs.
         bool is_force_signin_enabled = signin::IsForceSigninEnabled();
         InlineLoginHandlerImpl* handler = nullptr;
         if (is_force_signin_enabled)
           handler = this;
-        FinishCompleteLoginParams params(handler, partition, current_url, path,
-                                         confirm_untrusted_signin_, email,
-                                         gaia_id, password, session_index,
-                                         auth_code, choose_what_to_sync);
+        FinishCompleteLoginParams params(
+            handler, partition, current_url, path, confirm_untrusted_signin_,
+            email, gaia_id, password, session_index, auth_code,
+            choose_what_to_sync, is_force_signin_enabled);
         ProfileManager::CreateCallback callback =
             base::Bind(&InlineLoginHandlerImpl::FinishCompleteLogin, params);
         if (is_force_signin_enabled) {
           // Browser window will be opened after ClientOAuthSuccess.
           profiles::LoadProfileAsync(path, callback);
         } else {
           profiles::SwitchToProfile(path, true, callback,
                                     ProfileMetrics::SWITCH_PROFILE_UNLOCK);
         }
       }
     }
   } else {
     FinishCompleteLogin(
         FinishCompleteLoginParams(this, partition, current_url,
                                   base::FilePath(), confirm_untrusted_signin_,
                                   email, gaia_id, password, session_index,
-                                  auth_code, choose_what_to_sync),
-        profile,
-        Profile::CREATE_STATUS_CREATED);
+                                  auth_code, choose_what_to_sync, false),
+        profile, Profile::CREATE_STATUS_CREATED);
   }
 }
 
 InlineLoginHandlerImpl::FinishCompleteLoginParams::FinishCompleteLoginParams(
     InlineLoginHandlerImpl* handler,
     content::StoragePartition* partition,
     const GURL& url,
     const base::FilePath& profile_path,
     bool confirm_untrusted_signin,
     const std::string& email,
     const std::string& gaia_id,
     const std::string& password,
     const std::string& session_index,
     const std::string& auth_code,
-    bool choose_what_to_sync)
+    bool choose_what_to_sync,
+    bool is_force_sign_in_with_usermanager)
     : handler(handler),
       partition(partition),
       url(url),
       profile_path(profile_path),
       confirm_untrusted_signin(confirm_untrusted_signin),
       email(email),
       gaia_id(gaia_id),
       password(password),
       session_index(session_index),
       auth_code(auth_code),
-      choose_what_to_sync(choose_what_to_sync) {}
+      choose_what_to_sync(choose_what_to_sync),
+      is_force_sign_in_with_usermanager(is_force_sign_in_with_usermanager) {}
 
 InlineLoginHandlerImpl::FinishCompleteLoginParams::FinishCompleteLoginParams(
     const FinishCompleteLoginParams& other) = default;
 
 InlineLoginHandlerImpl::
     FinishCompleteLoginParams::~FinishCompleteLoginParams() {}
 
 // static
 void InlineLoginHandlerImpl::FinishCompleteLogin(
     const FinishCompleteLoginParams& params,
@@ skipping 73 matching lines @@
       signin_client->GetSigninScopedDeviceId();
   base::WeakPtr<InlineLoginHandlerImpl> handler_weak_ptr;
   if (params.handler)
     handler_weak_ptr = params.handler->GetWeakPtr();
 
   // InlineSigninHelper will delete itself.
   new InlineSigninHelper(
       handler_weak_ptr, params.partition->GetURLRequestContext(), profile,
       status, params.url, params.email, params.gaia_id, params.password,
       params.session_index, params.auth_code, signin_scoped_device_id,
-      params.choose_what_to_sync, params.confirm_untrusted_signin);
+      params.choose_what_to_sync, params.confirm_untrusted_signin,
+      params.is_force_sign_in_with_usermanager);
 
   // If opened from user manager to unlock a profile, make sure the user manager
   // is closed and that the profile is marked as unlocked.
-  if (!signin::IsForceSigninEnabled()) {
+  if (!params.is_force_sign_in_with_usermanager) {
     UnlockProfileAndHideLoginUI(params.profile_path, params.handler);
   }
 }
 
 void InlineLoginHandlerImpl::HandleLoginError(const std::string& error_msg,
                                               const base::string16& email) {
   SyncStarterCallback(OneClickSigninSyncStarter::SYNC_SETUP_FAILURE);
   Browser* browser = GetDesktopBrowser();
   Profile* profile = Profile::FromWebUI(web_ui());
 
@@ skipping 59 matching lines @@
 
     if (show_account_management) {
       browser->window()->ShowAvatarBubbleFromAvatarButton(
           BrowserWindow::AVATAR_BUBBLE_MODE_ACCOUNT_MANAGEMENT,
           signin::ManageAccountsParams(),
           signin_metrics::AccessPoint::ACCESS_POINT_AVATAR_BUBBLE_SIGN_IN,
           false);
     }
   }
 }