Clean up LoginUIService. Remove Singleton behavior from PeopleHandler

chrome/browser/ui/webui/settings/people_handler.cc

 // Copyright 2015 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/settings/people_handler.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 146 matching lines @@
 
 PeopleHandler::~PeopleHandler() {
   // Early exit if running unit tests (no actual WebUI is attached).
   if (!web_ui())
     return;
 
   // This case is hit when the user performs a back navigation.
   CloseSyncSetup();
 }
 
-bool PeopleHandler::IsActiveLogin() const {
-  // LoginUIService can be nullptr if page is brought up in incognito mode
-  // (i.e. if the user is running in guest mode in cros and brings up settings).
-  LoginUIService* service = GetLoginUIService();
-  return service && (service->current_login_ui() == this);
-}
-
 void PeopleHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "SyncSetupDidClosePage",
       base::Bind(&PeopleHandler::OnDidClosePage, base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "SyncSetupSetDatatypes",
       base::Bind(&PeopleHandler::HandleSetDatatypes, base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "SyncSetupSetEncryption",
       base::Bind(&PeopleHandler::HandleSetEncryption, base::Unretained(this)));
@@ skipping 100 matching lines @@
           access_point, signin_metrics::Reason::REASON_SIGNIN_PRIMARY_ACCOUNT,
           true);
     }
   }
 
   if (url.is_valid())
     chrome::ShowSingletonTab(browser, url);
 }
 #endif
 
-bool PeopleHandler::PrepareSyncSetup() {
-  // If the wizard is already visible, just focus that one.
-  if (FocusExistingWizardIfPresent()) {
-    if (!IsActiveLogin())
-      CloseSyncSetup();
-    return false;
-  }
-
-  // Notify services that login UI is now active.
-  GetLoginUIService()->SetLoginUI(this);
-
-  ProfileSyncService* service = GetSyncService();
-  if (service)
-    service->SetSetupInProgress(true);
-
-  return true;
-}
-
 void PeopleHandler::DisplaySpinner() {
   configuring_sync_ = true;
 
   const int kTimeoutSec = 30;
   DCHECK(!backend_start_timer_);
   backend_start_timer_.reset(new base::OneShotTimer());
   backend_start_timer_->Start(FROM_HERE,
                               base::TimeDelta::FromSeconds(kTimeoutSec), this,
                               &PeopleHandler::DisplayTimeout);
 
@@ skipping 170 matching lines @@
     // For web-based signin, the signin page is not displayed in an overlay
     // on the settings page. So if we get here, it must be due to the user
     // cancelling signin (by reloading the sync settings page during initial
     // signin) or by directly navigating to settings/syncSetup
     // (http://crbug.com/229836). So just exit and go back to the settings page.
     DLOG(WARNING) << "Cannot display sync setup UI when not signed in";
     CloseUI();
     return;
   }
 
-  // If a setup wizard is already present, but not on this page, close the
-  // blank setup overlay on this page by showing the "done" page. This can
-  // happen if the user navigates to chrome://settings/syncSetup in more than
-  // one tab. See crbug.com/261566.
-  // Note: The following block will transfer focus to the existing wizard.
-  if (IsExistingWizardPresent() && !IsActiveLogin())
-    CloseUI();
-
-  // If a setup wizard is present on this page or another, bring it to focus.
-  // Otherwise, display a new one on this page.
-  if (!FocusExistingWizardIfPresent())
-    OpenSyncSetup(false /* creating_supervised_user */);
+  OpenSyncSetup(false /* creating_supervised_user */);
 }
 
 #if defined(OS_CHROMEOS)
 // On ChromeOS, we need to sign out the user session to fix an auth error, so
 // the user goes through the real signin flow to generate a new auth token.
 void PeopleHandler::HandleDoSignOutOnAuthError(const base::ListValue* args) {
   DVLOG(1) << "Signing out the user to fix a sync error.";
   chrome::AttemptUserExit();
 }
 #endif
@@ skipping 44 matching lines @@
 }
 
 void PeopleHandler::CloseSyncSetup() {
   // Stop a timer to handle timeout in waiting for checking network connection.
   backend_start_timer_.reset();
 
   // Clear the sync startup tracker, since the setup wizard is being closed.
   sync_startup_tracker_.reset();
 
   ProfileSyncService* sync_service = GetSyncService();
-  if (IsActiveLogin()) {
+
+  // LoginUIService can be nullptr if page is brought up in incognito mode
+  // (i.e. if the user is running in guest mode in cros and brings up settings).
+  LoginUIService* service = GetLoginUIService();
+  if (service && (service->current_login_ui() == this)) {
     // Don't log a cancel event if the sync setup dialog is being
     // automatically closed due to an auth error.
     if (!sync_service || (!sync_service->IsFirstSetupComplete() &&
                           sync_service->GetAuthError().state() ==
                               GoogleServiceAuthError::NONE)) {
       if (configuring_sync_) {
         ProfileSyncService::SyncEvent(
             ProfileSyncService::CANCEL_DURING_CONFIGURE);
 
         // If the user clicked "Cancel" while setting up sync, disable sync
@@ skipping 25 matching lines @@
   // Alert the sync service anytime the sync setup dialog is closed. This can
   // happen due to the user clicking the OK or Cancel button, or due to the
   // dialog being closed by virtue of sync being disabled in the background.
   if (sync_service)
     sync_service->SetSetupInProgress(false);
 
   configuring_sync_ = false;
 }
 
 void PeopleHandler::OpenSyncSetup(bool creating_supervised_user) {
-  if (!PrepareSyncSetup())
-    return;
+  // Notify services that login UI is now active.
+  GetLoginUIService()->SetLoginUI(this);
+
+  ProfileSyncService* service = GetSyncService();
+  if (service)
+    service->SetSetupInProgress(true);
 
   // There are several different UI flows that can bring the user here:
   // 1) Signin promo.
   // 2) Normal signin through settings page (IsAuthenticated() is false).
   // 3) Previously working credentials have expired.
   // 4) User is signed in, but has stopped sync via the google dashboard, and
   //    signout is prohibited by policy so we need to force a re-auth.
   // 5) User clicks [Advanced Settings] button on options page while already
   //    logged in.
   // 6) One-click signin (credentials are already available, so should display
   //    sync configure UI, not login UI).
   // 7) User re-enables sync after disabling it via advanced settings.
 #if !defined(OS_CHROMEOS)
   SigninManagerBase* signin = SigninManagerFactory::GetForProfile(profile_);
   if (!signin->IsAuthenticated() ||
       SigninErrorControllerFactory::GetForProfile(profile_)->HasError()) {
     // User is not logged in (cases 1-2), or login has been specially requested
     // because previously working credentials have expired (case 3). Close sync
     // setup including any visible overlays, and display the gaia auth page.
     // Control will be returned to the sync settings page once auth is complete.
     CloseUI();
     DisplayGaiaLogin(
         creating_supervised_user ?
             signin_metrics::AccessPoint::ACCESS_POINT_SUPERVISED_USER :
             signin_metrics::AccessPoint::ACCESS_POINT_SETTINGS);
     return;
   }
 #endif
-  if (!GetSyncService()) {
+  if (!service) {
     // This can happen if the user directly navigates to /settings/syncSetup.
     DLOG(WARNING) << "Cannot display sync UI when sync is disabled";
     CloseUI();
     return;
   }
 
   // User is already logged in. They must have brought up the config wizard
   // via the "Advanced..." button or through One-Click signin (cases 4-6), or
   // they are re-enabling sync after having disabled it (case 7).
   PushSyncPrefs();
-  FocusUI();
 }
 
 void PeopleHandler::FocusUI() {
-  DCHECK(IsActiveLogin());
   WebContents* web_contents = web_ui()->GetWebContents();
   web_contents->GetDelegate()->ActivateContents(web_contents);
 }
 
 void PeopleHandler::CloseUI() {
   CloseSyncSetup();
   CallJavascriptFunction("cr.webUIListenerCallback",
                          base::StringValue("page-status-changed"),
                          base::StringValue(kDonePageStatus));
 }
@@ skipping 64 matching lines @@
   sync_status->SetBoolean("hasError", status_has_error);
 
   sync_status->SetBoolean("managed", service && service->IsManaged());
   sync_status->SetBoolean("signedIn", signin->IsAuthenticated());
   sync_status->SetBoolean("hasUnrecoverableError",
                           service && service->HasUnrecoverableError());
 
   return sync_status;
 }
 
-bool PeopleHandler::IsExistingWizardPresent() {
-  LoginUIService* service = GetLoginUIService();
-  DCHECK(service);
-  return service->current_login_ui() != nullptr;
-}
-
-bool PeopleHandler::FocusExistingWizardIfPresent() {
-  if (!IsExistingWizardPresent())
-    return false;
-
-  LoginUIService* service = GetLoginUIService();
-  DCHECK(service);
-  service->current_login_ui()->FocusUI();
-  return true;
-}
-
 void PeopleHandler::PushSyncPrefs() {
 #if !defined(OS_CHROMEOS)
   // Early exit if the user has not signed in yet.
   if (!SigninManagerFactory::GetForProfile(profile_)->IsAuthenticated() ||
       SigninErrorControllerFactory::GetForProfile(profile_)->HasError()) {
     return;
   }
 #endif
 
   // Early exit if there is already a preferences push pending sync startup.
@@ skipping 132 matching lines @@
   base::FilePath profile_file_path = profile_->GetPath();
   ProfileMetrics::LogProfileSyncSignIn(profile_file_path);
 
   // We're done configuring, so notify ProfileSyncService that it is OK to
   // start syncing.
   service->SetSetupInProgress(false);
   service->SetFirstSetupComplete();
 }
 
 }  // namespace settings