Revert 275154 "ChromeOS login webui refactoring : Move GAIA-rela..."

trunk/src/chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h

 // Copyright (c) 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.
 
 #ifndef CHROME_BROWSER_UI_WEBUI_CHROMEOS_LOGIN_SIGNIN_SCREEN_HANDLER_H_
 #define CHROME_BROWSER_UI_WEBUI_CHROMEOS_LOGIN_SIGNIN_SCREEN_HANDLER_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 26 matching lines @@
 namespace base {
 class DictionaryValue;
 class ListValue;
 }
 
 namespace chromeos {
 
 class AuthenticatedUserEmailRetriever;
 class CaptivePortalWindowProxy;
 class CoreOobeActor;
-class GaiaScreenHandler;
 class LocallyManagedUserCreationScreenHandler;
 class NativeWindowDelegate;
 class User;
 class UserContext;
 
 // Helper class to pass initial parameters to the login screen.
 class LoginScreenContext {
  public:
   LoginScreenContext();
   explicit LoginScreenContext(const base::ListValue* args);
@@ skipping 188 matching lines @@
     kiosk_enable_flow_aborted_callback_for_test_ = callback;
   }
 
  private:
   enum UIState {
     UI_STATE_UNKNOWN = 0,
     UI_STATE_GAIA_SIGNIN,
     UI_STATE_ACCOUNT_PICKER,
   };
 
-  friend class GaiaScreenHandler;
+  friend class ReportDnsCacheClearedOnUIThread;
   friend class LocallyManagedUserCreationScreenHandler;
-  friend class ReportDnsCacheClearedOnUIThread;
 
   void ShowImpl();
 
   // Updates current UI of the signin screen according to |ui_state|
   // argument.  Optionally it can pass screen initialization data via
   // |params| argument.
   void UpdateUIState(UIState ui_state, base::DictionaryValue* params);
 
   void UpdateStateInternal(ErrorScreenActor::ErrorReason reason,
                            bool force_update);
@@ skipping 46 matching lines @@
                                      const gfx::Image& icon) OVERRIDE;
   virtual void HideUserPodCustomIcon(const std::string& username) OVERRIDE;
   virtual void EnableInput() OVERRIDE;
   virtual void SetAuthType(const std::string& username,
                            ScreenlockBridge::LockHandler::AuthType auth_type,
                            const std::string& initial_value) OVERRIDE;
   virtual ScreenlockBridge::LockHandler::AuthType GetAuthType(
       const std::string& username) const OVERRIDE;
   virtual void Unlock(const std::string& user_email) OVERRIDE;
 
+  // Shows signin screen after dns cache and cookie cleanup operations finish.
+  void ShowSigninScreenIfReady();
+
+  // Tells webui to load authentication extension. |force| is used to force the
+  // extension reloading, if it has already been loaded. |silent_load| is true
+  // for cases when extension should be loaded in the background and it
+  // shouldn't grab the focus. |offline| is true when offline version of the
+  // extension should be used.
+  void LoadAuthExtension(bool force, bool silent_load, bool offline);
+
   // Updates authentication extension. Called when device settings that affect
   // sign-in (allow BWSI and allow whitelist) are changed.
   void UserSettingsChanged();
   void UpdateAddButtonStatus();
 
   // Restore input focus to current user pod.
   void RefocusCurrentPod();
 
   // WebUI message handlers.
+  void HandleCompleteAuthentication(const std::string& email,
+                                    const std::string& password,
+                                    const std::string& auth_code);
+  void HandleCompleteLogin(const std::string& typed_email,
+                           const std::string& password,
+                           bool using_saml);
   void HandleGetUsers();
+  void HandleUsingSAMLAPI();
+  void HandleScrapedPasswordCount(int password_count);
+  void HandleScrapedPasswordVerificationFailed();
   void HandleAuthenticateUser(const std::string& username,
                               const std::string& password);
   void HandleAttemptUnlock(const std::string& username);
   void HandleLaunchDemoUser();
   void HandleLaunchIncognito();
   void HandleLaunchPublicAccount(const std::string& username);
   void HandleOfflineLogin(const base::ListValue* args);
   void HandleShutdownSystem();
   void HandleLoadWallpaper(const std::string& email);
   void HandleRebootSystem();
   void HandleRemoveUser(const std::string& email);
   void HandleShowAddUser(const base::ListValue* args);
   void HandleToggleEnrollmentScreen();
   void HandleToggleKioskEnableScreen();
   void HandleToggleResetScreen();
   void HandleToggleKioskAutolaunchScreen();
   void HandleCreateAccount();
   void HandleAccountPickerReady();
   void HandleWallpaperReady();
+  void HandleLoginWebuiReady();
   void HandleSignOutUser();
   void HandleOpenProxySettings();
   void HandleLoginVisible(const std::string& source);
   void HandleCancelPasswordChangedFlow();
   void HandleCancelUserAdding();
   void HandleMigrateUserData(const std::string& password);
   void HandleResyncUserData();
   void HandleLoginUIStateChanged(const std::string& source, bool new_value);
   void HandleUnlockOnLoginSuccess();
   void HandleLoginScreenUpdate();
   void HandleShowLoadingTimeoutError();
   void HandleUpdateOfflineLogin(bool offline_login_active);
   void HandleShowLocallyManagedUserCreationScreen();
   void HandleFocusPod(const std::string& user_id);
   void HandleLaunchKioskApp(const std::string& app_id, bool diagnostic_mode);
   void HandleRetrieveAuthenticatedUserEmail(double attempt_token);
 
+  // Kick off cookie / local storage cleanup.
+  void StartClearingCookies(const base::Closure& on_clear_callback);
+  void OnCookiesCleared(base::Closure on_clear_callback);
+
+  // Kick off DNS cache flushing.
+  void StartClearingDnsCache();
+  void OnDnsCleared();
+
+  // Decides whether an auth extension should be pre-loaded. If it should,
+  // pre-loads it.
+  void MaybePreloadAuthExtension();
 
   // Returns true iff
   // (i)   log in is restricted to some user list,
   // (ii)  all users in the restricted list are present.
   bool AllWhitelistedUsersPresent();
 
   // Cancels password changed flow - switches back to login screen.
   // Called as a callback after cookies are cleared.
   void CancelPasswordChangedFlowInternal();
 
@@ skipping 10 matching lines @@
   // Returns true if current screen is the error screen over signin
   // screen.
   bool IsSigninScreenHiddenByError() const;
 
   // Returns true if guest signin is allowed.
   bool IsGuestSigninAllowed() const;
 
   // Returns true if offline login is allowed.
   bool IsOfflineLoginAllowed() const;
 
-  bool ShouldLoadGaia() const;
+  // Attempts login for test.
+  void SubmitLoginFormForTest();
 
   // Update current input method (namely keyboard layout) to LRU by this user.
   void SetUserInputMethod(const std::string& username);
 
   // Invoked when auto enrollment check progresses to decide whether to
   // continue kiosk enable flow. Kiosk enable flow is resumed when
   // |state| indicates that enrollment is not applicable.
   void ContinueKioskEnableFlow(policy::AutoEnrollmentState state);
 
-  // Shows signin.
-  void OnShowAddUser();
+  // Shows signin screen for |email|.
+  void OnShowAddUser(const std::string& email);
+
+  // Updates the member variable and UMA histogram indicating whether the
+  // principals API was used during SAML login.
+  void SetSAMLPrincipalsAPIUsed(bool api_used);
 
   GaiaScreenHandler::FrameState FrameState() const;
   net::Error FrameError() const;
 
   // input_method::ImeKeyboard::Observer implementation:
   virtual void OnCapsLockChanged(bool enabled) OVERRIDE;
 
   // Current UI state of the signin screen.
   UIState ui_state_;
 
   // A delegate that glues this handler with backend LoginDisplay.
   SigninScreenHandlerDelegate* delegate_;
 
   // A delegate used to get gfx::NativeWindow.
   NativeWindowDelegate* native_window_delegate_;
 
   // Whether screen should be shown right after initialization.
   bool show_on_init_;
 
   // Keeps whether screen should be shown for OOBE.
   bool oobe_ui_;
 
+  // Is focus still stolen from Gaia page?
+  bool focus_stolen_;
+
+  // Has Gaia page silent load been started for the current sign-in attempt?
+  bool gaia_silent_load_;
+
+  // The active network at the moment when Gaia page was preloaded.
+  std::string gaia_silent_load_network_;
+
   // Is account picker being shown for the first time.
   bool is_account_picker_showing_first_time_;
 
+  // True if dns cache cleanup is done.
+  bool dns_cleared_;
+
+  // True if DNS cache task is already running.
+  bool dns_clear_task_running_;
+
+  // True if cookie jar cleanup is done.
+  bool cookies_cleared_;
+
   // Network state informer used to keep signin screen up.
   scoped_refptr<NetworkStateInformer> network_state_informer_;
 
+  // Email to pre-populate with.
+  std::string email_;
+  // Emails of the users, whose passwords have recently been changed.
+  std::set<std::string> password_changed_for_;
+
+  // If the user authenticated via SAML, this indicates whether the principals
+  // API was used.
+  bool using_saml_api_;
+
+  // Test credentials.
+  std::string test_user_;
+  std::string test_pass_;
+  bool test_expects_complete_login_;
+
+  base::WeakPtrFactory<SigninScreenHandler> weak_factory_;
+
   // Set to true once |LOGIN_WEBUI_VISIBLE| notification is observed.
   bool webui_visible_;
   bool preferences_changed_delayed_;
 
   ErrorScreenActor* error_screen_actor_;
   CoreOobeActor* core_oobe_actor_;
 
   bool is_first_update_state_call_;
   bool offline_login_active_;
   NetworkStateInformer::State last_network_state_;
@@ skipping 15 matching lines @@
 
   base::Closure kiosk_enable_flow_aborted_callback_for_test_;
 
   // Non-owning ptr.
   // TODO (ygorshenin@): remove this dependency.
   GaiaScreenHandler* gaia_screen_handler_;
 
   // Helper that retrieves the authenticated user's e-mail address.
   scoped_ptr<AuthenticatedUserEmailRetriever> email_retriever_;
 
-  base::WeakPtrFactory<SigninScreenHandler> weak_factory_;
-
   DISALLOW_COPY_AND_ASSIGN(SigninScreenHandler);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_UI_WEBUI_CHROMEOS_LOGIN_SIGNIN_SCREEN_HANDLER_H_