cros: Clean up screenlockPrivate plumbing.

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>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/chromeos/login/enrollment/auto_enrollment_controller.h"
 #include "chrome/browser/chromeos/login/login_display.h"
 #include "chrome/browser/chromeos/login/screens/error_screen_actor.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/net/network_portal_detector.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
+#include "chrome/browser/signin/screenlock_bridge.h"
 #include "chrome/browser/ui/webui/chromeos/login/base_screen_handler.h"
 #include "chrome/browser/ui/webui/chromeos/login/gaia_screen_handler.h"
 #include "chrome/browser/ui/webui/chromeos/login/network_state_informer.h"
 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/web_ui.h"
 #include "net/base/net_errors.h"
 #include "ui/events/event_handler.h"
 
@@ skipping 34 matching lines @@
 // An interface for WebUILoginDisplay to call SigninScreenHandler.
 class LoginDisplayWebUIHandler {
  public:
   virtual void ClearAndEnablePassword() = 0;
   virtual void ClearUserPodPassword() = 0;
   virtual void OnLoginSuccess(const std::string& username) = 0;
   virtual void OnUserRemoved(const std::string& username) = 0;
   virtual void OnUserImageChanged(const User& user) = 0;
   virtual void OnPreferencesChanged() = 0;
   virtual void ResetSigninScreenHandlerDelegate() = 0;
-  virtual void ShowBannerMessage(const std::string& message) = 0;
-  virtual void ShowUserPodButton(const std::string& username,
-                                 const std::string& iconURL,
-                                 const base::Closure& click_callback) = 0;
-  virtual void HideUserPodButton(const std::string& username) = 0;
-  virtual void SetAuthType(const std::string& username,
-                           LoginDisplay::AuthType auth_type,
-                           const std::string& initial_value) = 0;
-  virtual LoginDisplay::AuthType GetAuthType(const std::string& username)
-      const = 0;
   virtual void ShowError(int login_attempts,
                          const std::string& error_text,
                          const std::string& help_link_text,
                          HelpAppLauncher::HelpTopic help_topic_id) = 0;
   virtual void ShowErrorScreen(LoginDisplay::SigninError error_id) = 0;
   virtual void ShowGaiaPasswordChanged(const std::string& username) = 0;
   virtual void ShowSigninUI(const std::string& email) = 0;
   virtual void ShowControlBar(bool show) = 0;
   virtual void ShowPasswordChangedDialog(bool show_password_error) = 0;
   // Show sign-in screen for the given credentials.
@@ skipping 101 matching lines @@
   virtual ~SigninScreenHandlerDelegate() {}
 };
 
 // A class that handles the WebUI hooks in sign-in screen in OobeDisplay
 // and LoginDisplay.
 class SigninScreenHandler
     : public BaseScreenHandler,
       public LoginDisplayWebUIHandler,
       public content::NotificationObserver,
       public ui::EventHandler,
+      public ScreenlockBridge::LockHandler,
       public NetworkStateInformer::NetworkStateInformerObserver {
  public:
   SigninScreenHandler(
       const scoped_refptr<NetworkStateInformer>& network_state_informer,
       ErrorScreenActor* error_screen_actor,
       CoreOobeActor* core_oobe_actor,
       GaiaScreenHandler* gaia_screen_handler);
   virtual ~SigninScreenHandler();
 
   // Shows the sign in screen.
@@ skipping 54 matching lines @@
   virtual void RegisterMessages() OVERRIDE;
 
   // LoginDisplayWebUIHandler implementation:
   virtual void ClearAndEnablePassword() OVERRIDE;
   virtual void ClearUserPodPassword() OVERRIDE;
   virtual void OnLoginSuccess(const std::string& username) OVERRIDE;
   virtual void OnUserRemoved(const std::string& username) OVERRIDE;
   virtual void OnUserImageChanged(const User& user) OVERRIDE;
   virtual void OnPreferencesChanged() OVERRIDE;
   virtual void ResetSigninScreenHandlerDelegate() OVERRIDE;
-  virtual void ShowBannerMessage(const std::string& message) OVERRIDE;
-  virtual void ShowUserPodButton(const std::string& username,
-                                 const std::string& iconURL,
-                                 const base::Closure& click_callback) OVERRIDE;
-  virtual void HideUserPodButton(const std::string& username) OVERRIDE;
-  virtual void SetAuthType(const std::string& username,
-                           LoginDisplay::AuthType auth_type,
-                           const std::string& initial_value) OVERRIDE;
-  virtual LoginDisplay::AuthType GetAuthType(const std::string& username)
-      const OVERRIDE;
   virtual void ShowError(int login_attempts,
                          const std::string& error_text,
                          const std::string& help_link_text,
                          HelpAppLauncher::HelpTopic help_topic_id) OVERRIDE;
   virtual void ShowGaiaPasswordChanged(const std::string& username) OVERRIDE;
   virtual void ShowSigninUI(const std::string& email) OVERRIDE;
   virtual void ShowControlBar(bool show) OVERRIDE;
   virtual void ShowPasswordChangedDialog(bool show_password_error) OVERRIDE;
   virtual void ShowErrorScreen(LoginDisplay::SigninError error_id) OVERRIDE;
   virtual void ShowSigninScreenForCreds(const std::string& username,
                                         const std::string& password) OVERRIDE;
 
   // ui::EventHandler implementation:
   virtual void OnKeyEvent(ui::KeyEvent* key) OVERRIDE;
 
   // content::NotificationObserver implementation:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
+  // ScreenlockBridge::LockHandler implementation:
+  virtual void ShowBannerMessage(const std::string& message) OVERRIDE;
+  virtual void ShowUserPodCustomIcon(const std::string& username,
+                                     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);
 
@@ skipping 11 matching lines @@
                                     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();
@@ skipping 12 matching lines @@
   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 HandleCustomButtonClicked(const std::string& username);
   void HandleRetrieveAuthenticatedUserEmail(double attempt_token);
 
   // Fills |user_dict| with information about |user|.
-  static void FillUserDictionary(User* user,
-                                 bool is_owner,
-                                 bool is_signin_to_add,
-                                 LoginDisplay::AuthType auth_type,
-                                 base::DictionaryValue* user_dict);
+  static void FillUserDictionary(
+      User* user,
+      bool is_owner,
+      bool is_signin_to_add,
+      ScreenlockBridge::LockHandler::AuthType auth_type,
+      base::DictionaryValue* user_dict);
 
   // Sends user list to account picker.
   void SendUserList(bool animated);
 
   // 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();
@@ skipping 131 matching lines @@
 
   scoped_ptr<CrosSettings::ObserverSubscription> allow_new_user_subscription_;
   scoped_ptr<CrosSettings::ObserverSubscription> allow_guest_subscription_;
   scoped_ptr<AutoEnrollmentController::ProgressCallbackList::Subscription>
       auto_enrollment_progress_subscription_;
 
   bool caps_lock_enabled_;
 
   base::Closure kiosk_enable_flow_aborted_callback_for_test_;
 
-  // Map of callbacks run when the custom button on a user pod is clicked.
-  std::map<std::string, base::Closure> user_pod_button_callback_map_;
-
   // Map of usernames to their current authentication type. If a user is not
   // contained in the map, it is using the default authentication type.
-  std::map<std::string, LoginDisplay::AuthType> user_auth_type_map_;
+  std::map<std::string, ScreenlockBridge::LockHandler::AuthType>
+      user_auth_type_map_;
 
   // 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_;
 
   DISALLOW_COPY_AND_ASSIGN(SigninScreenHandler);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_UI_WEBUI_CHROMEOS_LOGIN_SIGNIN_SCREEN_HANDLER_H_