Create a new profile and sign in the user.

chrome/browser/ui/sync/one_click_signin_sync_starter.cc

 // 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.
 
 #include "chrome/browser/ui/sync/one_click_signin_sync_starter.h"
 
 #include <stddef.h>
 
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 62 matching lines @@
 
 }  // namespace
 
 OneClickSigninSyncStarter::OneClickSigninSyncStarter(
     Profile* profile,
     Browser* browser,
     const std::string& gaia_id,
     const std::string& email,
     const std::string& password,
     const std::string& refresh_token,
+    ProfileMode profile_mode,
     StartSyncMode start_mode,
     content::WebContents* web_contents,
     ConfirmationRequired confirmation_required,
     const GURL& current_url,
     const GURL& continue_url,
     Callback sync_setup_completed_callback)
     : content::WebContentsObserver(web_contents),
       profile_(nullptr),
       start_mode_(start_mode),
       confirmation_required_(confirmation_required),
       current_url_(current_url),
       continue_url_(continue_url),
       sync_setup_completed_callback_(sync_setup_completed_callback),
       first_account_added_to_cookie_(false),
       weak_pointer_factory_(this) {
   DCHECK(profile);
   DCHECK(web_contents || continue_url.is_empty());
   BrowserList::AddObserver(this);
   Initialize(profile, browser);
 
-  // Policy is enabled, so pass in a callback to do extra policy-related UI
-  // before signin completes.
-  SigninManagerFactory::GetForProfile(profile_)->
-      StartSignInWithRefreshToken(
-          refresh_token, gaia_id, email, password,
-          base::Bind(&OneClickSigninSyncStarter::ConfirmSignin,
-                     weak_pointer_factory_.GetWeakPtr()));
+  SigninManagerFactory::GetForProfile(profile_)->StartSignInWithRefreshToken(
+      refresh_token, gaia_id, email, password,
+      base::Bind(&OneClickSigninSyncStarter::ConfirmSignin,
+                 weak_pointer_factory_.GetWeakPtr(), profile_mode));
 }
 
 void OneClickSigninSyncStarter::OnBrowserRemoved(Browser* browser) {
   if (browser == browser_)
     browser_ = nullptr;
 }
 
 OneClickSigninSyncStarter::~OneClickSigninSyncStarter() {
   BrowserList::RemoveObserver(this);
   LoginUIServiceFactory::GetForProfile(profile_)->RemoveObserver(this);
@@ skipping 15 matching lines @@
   // Let the sync service know that setup is in progress so it doesn't start
   // syncing until the user has finished any configuration.
   ProfileSyncService* profile_sync_service = GetProfileSyncService();
   if (profile_sync_service)
     sync_blocker_ = profile_sync_service->GetSetupInProgressHandle();
 
   // Make sure the syncing is requested, otherwise the SigninManager
   // will not be able to complete successfully.
   syncer::SyncPrefs sync_prefs(profile_->GetPrefs());
   sync_prefs.SetSyncRequested(true);
-  skip_sync_confirm_ = false;
 }
 
-void OneClickSigninSyncStarter::ConfirmSignin(const std::string& oauth_token) {
+void OneClickSigninSyncStarter::ConfirmSignin(ProfileMode profile_mode,
+                                              const std::string& oauth_token) {
   DCHECK(!oauth_token.empty());
   SigninManager* signin = SigninManagerFactory::GetForProfile(profile_);
-  // If this is a new signin (no account authenticated yet) try loading
-  // policy for this user now, before any signed in services are initialized.
-  if (!signin->IsAuthenticated()) {
-    policy::UserPolicySigninService* policy_service =
-        policy::UserPolicySigninServiceFactory::GetForProfile(profile_);
-    policy_service->RegisterForPolicy(
-        signin->GetUsernameForAuthInProgress(),
-        oauth_token,
-        base::Bind(&OneClickSigninSyncStarter::OnRegisteredForPolicy,
-                   weak_pointer_factory_.GetWeakPtr()));
-    return;
-  } else {
+  if (signin->IsAuthenticated()) {
     // The user is already signed in - just tell SigninManager to continue
     // with its re-auth flow.
+    DCHECK_EQ(CURRENT_PROFILE, profile_mode);
     signin->CompletePendingSignin();
+    return;
+  }
+
+  switch (profile_mode) {
+    case CURRENT_PROFILE: {
+      // If this is a new signin (no account authenticated yet) try loading
+      // policy for this user now, before any signed in services are
+      // initialized.
+      policy::UserPolicySigninService* policy_service =
+          policy::UserPolicySigninServiceFactory::GetForProfile(profile_);
+      policy_service->RegisterForPolicy(
+          signin->GetUsernameForAuthInProgress(), oauth_token,
+          base::Bind(&OneClickSigninSyncStarter::OnRegisteredForPolicy,
+                     weak_pointer_factory_.GetWeakPtr()));
+      break;
+    }
+    case NEW_PROFILE:
+      // If this is a new signin (no account authenticated yet) in a new
+      // profile, then just create the new signed-in profile and skip loading
+      // the policy as there is no need to ask the user again if they should be
+      // signed in to a new profile. Note that in this case the policy will be
+      // applied after the new profile is signed in.
+      CreateNewSignedInProfile();
+      break;
   }
 }
 
 OneClickSigninSyncStarter::SigninDialogDelegate::SigninDialogDelegate(
     base::WeakPtr<OneClickSigninSyncStarter> sync_starter)
     : sync_starter_(sync_starter) {
 }
 
 OneClickSigninSyncStarter::SigninDialogDelegate::~SigninDialogDelegate() {
 }
@@ skipping 81 matching lines @@
   // we ever want to change this behavior, we could call
   // SigninManager::SignOut() here instead.
   DLOG_IF(ERROR, !success) << "Error fetching policy for user";
   DVLOG_IF(1, success) << "Policy fetch successful - completing signin";
   SigninManagerFactory::GetForProfile(profile_)->CompletePendingSignin();
 }
 
 void OneClickSigninSyncStarter::CreateNewSignedInProfile() {
   SigninManager* signin = SigninManagerFactory::GetForProfile(profile_);
   DCHECK(!signin->GetUsernameForAuthInProgress().empty());
-  DCHECK(!dm_token_.empty());
-  DCHECK(!client_id_.empty());
+
   // Create a new profile and have it call back when done so we can inject our
   // signin credentials.
   size_t icon_index = g_browser_process->profile_manager()->
       GetProfileAttributesStorage().ChooseAvatarIconIndexForNewProfile();
   ProfileManager::CreateMultiProfileAsync(
       base::UTF8ToUTF16(signin->GetUsernameForAuthInProgress()),
       profiles::GetDefaultAvatarIconUrl(icon_index),
       base::Bind(&OneClickSigninSyncStarter::CompleteInitForNewProfile,
                  weak_pointer_factory_.GetWeakPtr()),
       std::string());
@@ skipping 17 matching lines @@
     }
     case Profile::CREATE_STATUS_INITIALIZED: {
       // Wait until the profile is initialized before we transfer credentials.
       SigninManager* old_signin_manager =
           SigninManagerFactory::GetForProfile(profile_);
       SigninManager* new_signin_manager =
           SigninManagerFactory::GetForProfile(new_profile);
       DCHECK(!old_signin_manager->GetUsernameForAuthInProgress().empty());
       DCHECK(!old_signin_manager->IsAuthenticated());
       DCHECK(!new_signin_manager->IsAuthenticated());
-      DCHECK(!dm_token_.empty());
-      DCHECK(!client_id_.empty());
 
       // Copy credentials from the old profile to the just-created profile,
       // and switch over to tracking that profile.
       new_signin_manager->CopyCredentialsFrom(*old_signin_manager);
       FinishProfileSyncServiceSetup();
       Initialize(new_profile, nullptr);
       DCHECK_EQ(profile_, new_profile);
-      skip_sync_confirm_ = true;
 
       // We've transferred our credentials to the new profile - notify that
       // the signin for the original profile was cancelled (must do this after
       // we have called Initialize() with the new profile, as otherwise this
       // object will get freed when the signin on the old profile is cancelled.
       old_signin_manager->SignOut(signin_metrics::TRANSFER_CREDENTIALS,
                                   signin_metrics::SignoutDelete::IGNORE_METRIC);
 
-      // Load policy for the just-created profile - once policy has finished
-      // loading the signin process will complete.
-      LoadPolicyWithCachedCredentials();
+      if (!dm_token_.empty()) {
+        // Load policy for the just-created profile - once policy has finished
+        // loading the signin process will complete.
+        DCHECK(!client_id_.empty());
+        LoadPolicyWithCachedCredentials();
+      } else {
+        // No policy to load - simply complete the signin process.
+        SigninManagerFactory::GetForProfile(profile_)->CompletePendingSignin();
+      }
 
       // Unlock the new profile.
       ProfileAttributesEntry* entry;
       bool has_entry =
           g_browser_process->profile_manager()
               ->GetProfileAttributesStorage()
               .GetProfileAttributesWithPath(new_profile->GetPath(), &entry);
       DCHECK(has_entry);
       entry->SetIsSigninRequired(false);
 
@@ skipping 134 matching lines @@
 void OneClickSigninSyncStarter::AccountAddedToCookie(
     const GoogleServiceAuthError& error) {
   if (first_account_added_to_cookie_)
     return;
 
   first_account_added_to_cookie_ = true;
 
   // Regardless of whether the account was successfully added or not,
   // continue with sync starting.
 
-  // TODO(zmin): Remove this hack once the https://crbug.com/657924 fixed.

[anthonyvd, 2016/12/21 19:09:28]

Are you sure you can now remove this?

[msarda, 2016/12/22 11:58:05]

I have moved this change to its own CL
https://codereview.chromium.org/2600473002/

-  // Skip the Sync confirmation dialog if user choose to create a new profile
-  // for the corp signin. This is because the dialog doesn't work properly
-  // after the corp signin.
-  if (skip_sync_confirm_) {
-    OnSyncConfirmationUIClosed(LoginUIService::ABORT_SIGNIN);
-    return;
-  }
-
   if (switches::UsePasswordSeparatedSigninFlow()) {
     // Under the new signin flow, the sync confirmation dialog should always be
     // shown regardless of |start_mode_|. |sync_setup_completed_callback_| will
     // be run after the modal is closed.
     DisplayModalSyncConfirmationWindow();
     return;
   }
 
   if (!sync_setup_completed_callback_.is_null())
     sync_setup_completed_callback_.Run(SYNC_SETUP_SUCCESS);
@@ skipping 163 matching lines @@
                                             false /* user_gesture */);
 }
 
 void OneClickSigninSyncStarter::LoadContinueUrl() {
   web_contents()->GetController().LoadURL(
       continue_url_,
       content::Referrer(),
       ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
       std::string());
 }