cros: Initial structure for views-based lock.

chrome/browser/chromeos/login/lock/screen_locker.h

 // Copyright 2014 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_CHROMEOS_LOGIN_LOCK_SCREEN_LOCKER_H_
 #define CHROME_BROWSER_CHROMEOS_LOGIN_LOCK_SCREEN_LOCKER_H_
 
 #include <memory>
 #include <string>
 
 #include "base/callback_forward.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "base/time/time.h"
 #include "chrome/browser/chromeos/login/help_app_launcher.h"
 #include "chrome/browser/chromeos/login/ui/login_display.h"
 #include "chromeos/login/auth/auth_status_consumer.h"
 #include "chromeos/login/auth/user_context.h"
 #include "components/user_manager/user.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "services/device/public/interfaces/fingerprint.mojom.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/ime/chromeos/input_method_manager.h"
 
+namespace content {
+class WebContents;
+}
+
 namespace chromeos {
 
 class Authenticator;
 class ExtendedAuthenticator;
 class AuthFailure;
 class ScreenlockIconProvider;
 class WebUIScreenLocker;
 
 namespace test {
 class ScreenLockerTester;
 class ScreenLockerViewsTester;
 class WebUIScreenLockerTester;
 }  // namespace test
 
 // ScreenLocker creates a WebUIScreenLocker which will display the lock UI.
 // As well, it takes care of authenticating the user and managing a global
 // instance of itself which will be deleted when the system is unlocked.
 class ScreenLocker : public AuthStatusConsumer,
                      public device::mojom::FingerprintObserver {
  public:
+  enum class FingerprintState {
+    kHidden,
+    kDefault,
+    kSignin,
+    kFailed,
+    kRemoved,
+  };
+
+  // Delegate used to send internal state changes back to the UI.
+  class Delegate {
+   public:
+    Delegate();
+    virtual ~Delegate();
+
+    // Enable/disable password input.
+    virtual void SetInputEnabled(bool enabled) = 0;

[James Cook, 2017/05/08 22:04:21]

nit: SetPasswordEnabled() or SetPasswordInputEnabled()

[jdufault, 2017/05/08 23:02:35]

Done.

+
+    // Show the given error message.
+    virtual void ShowErrorMessage(int error_msg_id,
+                                  HelpAppLauncher::HelpTopic help_topic_id) = 0;
+
+    // Close any displayed error messages.
+    virtual void ClearErrors() = 0;
+
+    // Run any visual effects after authentication is successful. This must call
+    // ScreenLocker::UnlockOnLoginSuccess() after all effects are done.
+    virtual void AnimateAuthenticationSuccess() = 0;
+
+    // Called when the webui lock screen is ready. This gets invoked by a
+    // chrome.send from the embedded webui.
+    virtual void OnLockWebUIReady() = 0;
+
+    // Called when webui lock screen wallpaper is loaded and displayed.
+    virtual void OnLockBackgroundDisplayed() = 0;
+
+    // Called when the webui header bar becomes visible.
+    virtual void OnHeaderBarVisible() = 0;
+
+    // Called by ScreenLocker to notify that ash lock animation finishes.
+    virtual void OnAshLockAnimationFinished() = 0;
+
+    // Called when fingerprint state has changed.
+    virtual void SetFingerprintState(const AccountId& account_id,
+                                     FingerprintState state) = 0;
+
+    // Returns the web contents used to back the lock screen.
+    // TODO(jdufault): Remove this function when we remove WebUIScreenLocker.
+    virtual content::WebContents* GetWebContents() = 0;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(Delegate);
+  };

[James Cook, 2017/05/08 22:04:21]

nice method docs, by the way

[jdufault, 2017/05/08 23:02:35]

FYI: This section is mostly copied from webui_screen_locker.cc (I did some minor
cleanup though).

+
   explicit ScreenLocker(const user_manager::UserList& users);
 
   // Returns the default instance if it has been created.
   static ScreenLocker* default_screen_locker() {
     return screen_locker_;
   }
 
   bool locked() const { return locked_; }
 
   // Initialize and show the screen locker.
@@ skipping 23 matching lines @@
   // (Re)enable input field.
   void EnableInput();
 
   // Disables all UI needed and shows error bubble with |message|.
   // If |sign_out_only| is true then all other input except "Sign Out"
   // button is blocked.
   void ShowErrorMessage(int error_msg_id,
                         HelpAppLauncher::HelpTopic help_topic_id,
                         bool sign_out_only);
 
-  // Returns the WebUIScreenLocker used to lock the screen.
-  WebUIScreenLocker* web_ui() { return web_ui_.get(); }
+  // Returns the WebUIScreenLocker instance. This should only be used in tests.
+  // When using views-based lock this will be a nullptr.
+  // TODO(jdufault): Remove this function, make tests agnostic to ui impl.
+  WebUIScreenLocker* web_ui_for_testing() { return web_ui_.get(); }
+
+  // Returns delegate that can be used to talk to the view-layer.
+  Delegate* delegate() { return delegate_; }
 
   // Returns the users to authenticate.
   const user_manager::UserList& users() const { return users_; }
 
   // Allow a AuthStatusConsumer to listen for
   // the same login events that ScreenLocker does.
   void SetLoginStatusConsumer(chromeos::AuthStatusConsumer* consumer);
 
   // Initialize or uninitialize the ScreenLocker class. It listens to
   // NOTIFICATION_SESSION_STARTED so that the screen locker accepts lock
@@ skipping 59 matching lines @@
   const user_manager::User* FindUnlockUser(const AccountId& account_id);
 
   // Callback to be invoked for ash start lock request. |locked| is true when
   // ash is fully locked and post lock animation finishes. Otherwise, the start
   // lock request is failed.
   void OnStartLockCallback(bool locked);
 
   // WebUIScreenLocker instance in use.
   std::unique_ptr<WebUIScreenLocker> web_ui_;
 
+  // Delegate used to talk to the view.
+  Delegate* delegate_ = nullptr;
+  bool owns_delegate_ = false;
+
   // Users that can unlock the device.
   user_manager::UserList users_;
 
   // Used to authenticate the user to unlock.
   scoped_refptr<Authenticator> authenticator_;
 
   // Used to authenticate the user to unlock supervised users.
   scoped_refptr<ExtendedAuthenticator> extended_authenticator_;
 
   // True if the screen is locked, or false otherwise.  This changes
@@ skipping 33 matching lines @@
   mojo::Binding<device::mojom::FingerprintObserver> binding_;
 
   base::WeakPtrFactory<ScreenLocker> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenLocker);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_LOGIN_LOCK_SCREEN_LOCKER_H_