signin: pull basic SigninManager functionality into new SigninManagerBase class.

chrome/browser/ui/webui/sync_setup_handler.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/webui/sync_setup_handler.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/i18n/time_formatting.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profile_metrics.h"
-#include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/sync/signin_histogram.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/webui/signin/login_ui_service.h"
 #include "chrome/browser/ui/webui/signin/login_ui_service_factory.h"
 #include "chrome/browser/ui/webui/sync_promo/sync_promo_ui.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "ui/base/l10n/l10n_util.h"
 
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/signin/signin_manager_base.h"
+#else
+#include "chrome/browser/signin/signin_manager.h"
+#endif
+
 using content::WebContents;
 using l10n_util::GetStringFUTF16;
 using l10n_util::GetStringUTF16;
 
 namespace {
 
 // A structure which contains all the configuration information for sync.
 struct SyncConfigInfo {
   SyncConfigInfo();
   ~SyncConfigInfo();
@@ skipping 490 matching lines @@
   LoginUIService* service = GetLoginUIService();
   return service && (service->current_login_ui() == this);
 }
 
 void SyncSetupHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "SyncSetupDidClosePage",
       base::Bind(&SyncSetupHandler::OnDidClosePage,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
-      "SyncSetupSubmitAuth",
-      base::Bind(&SyncSetupHandler::HandleSubmitAuth,
-                 base::Unretained(this)));
-  web_ui()->RegisterMessageCallback(
       "SyncSetupConfigure",
       base::Bind(&SyncSetupHandler::HandleConfigure,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "SyncSetupAttachHandler",
       base::Bind(&SyncSetupHandler::HandleAttachHandler,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "SyncSetupShowErrorUI",
       base::Bind(&SyncSetupHandler::HandleShowErrorUI,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "SyncSetupShowSetupUI",
       base::Bind(&SyncSetupHandler::HandleShowSetupUI,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "SyncSetupShowSetupUIWithoutLogin",
       base::Bind(&SyncSetupHandler::HandleShowSetupUIWithoutLogin,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "SyncSetupDoSignOutOnAuthError",
       base::Bind(&SyncSetupHandler::HandleDoSignOutOnAuthError,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("CloseTimeout",
       base::Bind(&SyncSetupHandler::HandleCloseTimeout,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("SyncSetupStopSyncing",
       base::Bind(&SyncSetupHandler::HandleStopSyncing,
                  base::Unretained(this)));
-}
-
-SigninManager* SyncSetupHandler::GetSignin() const {
-  return SigninManagerFactory::GetForProfile(GetProfile());
+#if !defined(OS_CHROMEOS)
+  web_ui()->RegisterMessageCallback(
+      "SyncSetupSubmitAuth",
+      base::Bind(&SyncSetupHandler::HandleSubmitAuth,
+                 base::Unretained(this)));
+#endif
 }
 
 void SyncSetupHandler::DisplayGaiaLogin(bool fatal_error) {
   if (SyncPromoUI::UseWebBasedSigninFlow()) {
     // Advanced options are no longer being configured if the login screen is
     // visible. If the user exits the signin wizard after this without
     // configuring sync, CloseSyncSetup() will ensure they are logged out.
     configuring_sync_ = false;
 
     DisplayGaiaLoginInNewTabOrWindow();
@@ skipping 64 matching lines @@
     user = last_attempted_user_email_;
     error = last_signin_error_.state();
     captcha = last_signin_error_.captcha().image_url.spec();
     editable_user = true;
 
     if (local_error_message.empty())
       local_error_message = UTF8ToUTF16(last_signin_error_.error_message());
   } else {
     // Fresh login attempt - lock in the authenticated username if there is
     // one (don't let the user change it).
-    user = GetSignin()->GetAuthenticatedUsername();
+    user = SigninManagerFactory::GetForProfile(GetProfile())->
+        GetAuthenticatedUsername();
     error = 0;
     editable_user = user.empty();
   }
   DictionaryValue args;
   args.SetString("user", user);
   args.SetInteger("error", error);
 
   // If the error is two-factor, then ask for an OTP if the ClientOAuth flow
   // is enasbled.  Otherwise ask for an ASP.  If the error is catptcha required,
   // then we don't want to show username and password fields if ClientOAuth is
@@ skipping 84 matching lines @@
   if (SyncPromoUI::UseWebBasedSigninFlow())
     CloseGaiaSigninPage();
 
   web_ui()->CallJavascriptFunction("SyncSetupOverlay.showSuccessAndSettingUp");
 }
 
 void SyncSetupHandler::OnDidClosePage(const ListValue* args) {
   CloseSyncSetup();
 }
 
+#if !defined (OS_CHROMEOS)
 void SyncSetupHandler::HandleSubmitAuth(const ListValue* args) {
   std::string json;
   if (!args->GetString(0, &json)) {
     NOTREACHED() << "Could not read JSON argument";
     return;
   }
 
   if (json.empty())
     return;
 
@@ skipping 37 matching lines @@
   // Make sure we are listening for signin traffic.
   if (!signin_tracker_.get())
     signin_tracker_.reset(new SigninTracker(GetProfile(), this));
 
   last_attempted_user_email_ = username;
 
   // User is trying to log in again so reset the cached error.
   GoogleServiceAuthError current_error = last_signin_error_;
   last_signin_error_ = GoogleServiceAuthError::AuthErrorNone();
 
-  SigninManager* signin = GetSignin();
+  SigninManager* signin = SigninManagerFactory::GetForProfile(GetProfile());
 
   // If we're just being called to provide an ASP, then pass it to the
   // SigninManager and wait for the next step.
   if (!access_code.empty()) {
     signin->ProvideSecondFactorAccessCode(access_code);
     return;
   }
 
   // The user has submitted credentials, which indicates they don't want to
   // suppress start up anymore. We do this before starting the signin process,
   // so the ProfileSyncService knows to listen to the cached password.
   ProfileSyncService* service = GetSyncService();
   if (service)
     service->UnsuppressAndStart();
 
   // Kick off a sign-in through the signin manager.
   signin->StartSignIn(username, password, current_error.captcha().token,
                       solution);
 }
+#endif  // !defined (OS_CHROMEOS)
 
 void SyncSetupHandler::GaiaCredentialsValid() {
   DCHECK(IsActiveLogin());
 
   // Gaia credentials are valid - update the UI.
   DisplayGaiaSuccessAndSettingUp();
 }
 
 void SyncSetupHandler::SigninFailed(const GoogleServiceAuthError& error) {
   // Stop a timer to handle timeout in waiting for checking network connection.
@@ skipping 185 matching lines @@
 
 void SyncSetupHandler::HandleDoSignOutOnAuthError(const ListValue* args) {
   DLOG(INFO) << "Signing out the user to fix a sync error.";
   chrome::AttemptUserExit();
 }
 
 void SyncSetupHandler::HandleStopSyncing(const ListValue* args) {
   if (GetSyncService())
     ProfileSyncService::SyncEvent(ProfileSyncService::STOP_FROM_OPTIONS);
 
-  GetSignin()->SignOut();
+  SigninManagerFactory::GetForProfile(GetProfile())->SignOut();
 }
 
 void SyncSetupHandler::HandleCloseTimeout(const ListValue* args) {
   CloseSyncSetup();
 }
 
 void SyncSetupHandler::CloseSyncSetup() {
   // TODO(atwilson): Move UMA tracking of signin events out of sync module.
   ProfileSyncService* sync_service = GetSyncService();
   if (IsActiveLogin()) {
@@ skipping 32 matching lines @@
         // scenario:
         //   * User signs in while sync is disabled by policy.
         //   * Sync is re-enabled by policy.
         //   * User brings up sync setup dialog to do initial sync config.
         //   * User cancels out of the dialog.
         //
         // This case is indistinguishable from the "one click signin" case where
         // the user checks the "advanced setup" checkbox, then cancels out of
         // the setup box, which is a much more common scenario, so we do the
         // right thing for the one-click case.
-        GetSignin()->SignOut();
+        SigninManagerFactory::GetForProfile(GetProfile())->SignOut();
       }
       sync_service->DisableForUser();
       browser_sync::SyncPrefs sync_prefs(GetProfile()->GetPrefs());
       sync_prefs.SetStartSuppressed(true);
     }
     sync_service->SetSetupInProgress(false);
   }
 
   // Reset the attempted email address and error, otherwise the sync setup
   // overlay in the settings page will stay in whatever error state it was last
@@ skipping 19 matching lines @@
   // 3) Previously working credentials have expired.
   // 4) User is already signed in, but App Notifications needs to force another
   //    login so it can fetch an oauth token (passes force_login=true)
   // 5) 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.
   // 6) User clicks [Advanced Settings] button on options page while already
   //    logged in.
   // 7) One-click signin (credentials are already available, so should display
   //    sync configure UI, not login UI).
   // 8) ChromeOS re-enable after disabling sync.
-  SigninManager* signin = GetSignin();
+  SigninManagerBase* signin =
+      SigninManagerFactory::GetForProfile(GetProfile());
   if (force_login ||
       signin->GetAuthenticatedUsername().empty() ||
 #if !defined(OS_CHROMEOS)
       (GetSyncService() && GetSyncService()->IsStartSuppressed()) ||
 #endif
       signin->signin_global_error()->HasMenuItem()) {
     // User is not logged in, or login has been specially requested - need to
     // display login UI (cases 1-4).
     DisplayGaiaLogin(false);
   } else {
@@ skipping 122 matching lines @@
 
 bool SyncSetupHandler::IsLoginAuthDataValid(const std::string& username,
                                             string16* error_message) {
   if (username.empty())
     return true;
 
   // Can be null during some unit tests.
   if (!web_ui())
     return true;
 
-  if (!GetSignin()->IsAllowedUsername(username)) {
+  if (!SigninManagerFactory::GetForProfile(
+          GetProfile())->IsAllowedUsername(username)) {
     *error_message = l10n_util::GetStringUTF16(IDS_SYNC_LOGIN_NAME_PROHIBITED);
     return false;
   }
 
   // If running in a unit test, skip profile check.
   if (!profile_manager_)
     return true;
 
   // Check if the username is already in use by another profile.
   const ProfileInfoCache& cache = profile_manager_->GetProfileInfoCache();
   size_t current_profile_index =
       cache.GetIndexOfProfileWithPath(GetProfile()->GetPath());
   string16 username_utf16 = UTF8ToUTF16(username);
 
   for (size_t i = 0; i < cache.GetNumberOfProfiles(); ++i) {
     if (i != current_profile_index && AreUserNamesEqual(
         cache.GetUserNameOfProfileAtIndex(i), username_utf16)) {
       *error_message = l10n_util::GetStringUTF16(
           IDS_SYNC_USER_NAME_IN_USE_ERROR);
       return false;
     }
   }
 
   return true;
 }