cros: Initial structure for views-based lock.

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

 // 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.
 
 #include "chrome/browser/chromeos/login/lock/screen_locker.h"
 
 #include <string>
 #include <vector>
 
+#include "ash/login/views/lock_screen.h"
+#include "ash/public/interfaces/constants.mojom.h"
+#include "ash/public/interfaces/session_controller.mojom.h"
 #include "ash/shell.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/wm_event.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/macros.h"
@@ skipping 19 matching lines @@
 #include "chrome/browser/signin/easy_unlock_service.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/ui/ash/ash_util.h"
 #include "chrome/browser/ui/ash/session_controller_client.h"
 #include "chrome/browser/ui/webui/chromeos/login/screenlock_icon_provider.h"
 #include "chrome/browser/ui/webui/chromeos/login/screenlock_icon_source.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/grit/browser_resources.h"
 #include "chrome/grit/generated_resources.h"
 #include "chromeos/audio/chromeos_sounds.h"
+#include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "chromeos/login/auth/authenticator.h"
 #include "chromeos/login/auth/extended_authenticator.h"
 #include "chromeos/network/portal_detector/network_portal_detector.h"
 #include "components/session_manager/core/session_manager.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/user_manager/user_manager.h"
 #include "components/user_manager/user_type.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/url_data_source.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/common/service_manager_connection.h"
 #include "media/audio/sounds/sounds_manager.h"
 #include "services/device/public/interfaces/constants.mojom.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/display/display.h"
+#include "ui/display/screen.h"
 #include "ui/gfx/image/image.h"
 #include "url/gurl.h"
 
 using base::UserMetricsAction;
 using content::BrowserThread;
 
 namespace chromeos {
 
 namespace {
 
 // Timeout for unlock animation guard - some animations may be required to run
 // on successful authentication before unlocking, but we want to be sure that
 // unlock happens even if animations are broken.
 const int kUnlockGuardTimeoutMs = 400;
 
+// Returns true if we are using md-based login/lock.
+bool IsUsingMdLogin() {
+  return base::CommandLine::ForCurrentProcess()->HasSwitch(
+      chromeos::switches::kShowMdLogin);
+}
+
 // Returns true if fingerprint authentication is available for one of the
 // |users|.
 bool IsFingerprintAuthenticationAvailableForUsers(
     const user_manager::UserList& users) {
   for (auto* user : users) {
     quick_unlock::QuickUnlockStorage* quick_unlock_storage =
         quick_unlock::QuickUnlockFactory::GetForUser(user);
     if (quick_unlock_storage &&
         quick_unlock_storage->IsFingerprintAuthenticationAvailable()) {
       return true;
@@ skipping 10 matching lines @@
   ScreenLockObserver() : session_started_(false) {
     registrar_.Add(this,
                    chrome::NOTIFICATION_SESSION_STARTED,
                    content::NotificationService::AllSources());
     DBusThreadManager::Get()->GetSessionManagerClient()->SetStubDelegate(this);
   }
 
   ~ScreenLockObserver() override {
     if (DBusThreadManager::IsInitialized()) {
       DBusThreadManager::Get()->GetSessionManagerClient()->SetStubDelegate(
-          NULL);
+          nullptr);
     }
   }
 
   bool session_started() const { return session_started_; }
 
   // SessionManagerClient::StubDelegate overrides:
   void LockScreenForStub() override { ScreenLocker::HandleLockScreenRequest(); }
 
   // NotificationObserver overrides:
   void Observe(int type,
@@ skipping 21 matching lines @@
     ScreenLocker::HandleLockScreenRequest();
   }
 
  private:
   bool session_started_;
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenLockObserver);
 };
 
-ScreenLockObserver* g_screen_lock_observer = NULL;
+// Stubbed delegate that will eventually be replaced by mojo calls.
+class StubDelegate : public ScreenLocker::Delegate {
+ public:
+  StubDelegate() {}
+  ~StubDelegate() override {}
+
+  // ScreenLocker::Delegate:
+  void SetInputEnabled(bool enabled) override { NOTIMPLEMENTED(); }
+  void ShowErrorMessage(int error_msg_id,
+                        HelpAppLauncher::HelpTopic help_topic_id) override {
+    NOTIMPLEMENTED();
+  }
+  void ClearErrors() override { NOTIMPLEMENTED(); }
+  void AnimateAuthenticationSuccess() override { NOTIMPLEMENTED(); }
+  void OnLockWebUIReady() override { NOTIMPLEMENTED(); }
+  void OnLockBackgroundDisplayed() override { NOTIMPLEMENTED(); }
+  void OnHeaderBarVisible() override { NOTIMPLEMENTED(); }
+  void OnAshLockAnimationFinished() override { NOTIMPLEMENTED(); }
+  void SetFingerprintState(const AccountId& account_id,
+                           ScreenLocker::FingerprintState state) override {
+    NOTIMPLEMENTED();
+  }
+  content::WebContents* GetWebContents() override { return nullptr; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(StubDelegate);
+};
+
+ScreenLockObserver* g_screen_lock_observer = nullptr;
 
 }  // namespace
 
 // static
-ScreenLocker* ScreenLocker::screen_locker_ = NULL;
+ScreenLocker* ScreenLocker::screen_locker_ = nullptr;
+
+//////////////////////////////////////////////////////////////////////////////
+// ScreenLocker::Delegate, public:
+
+ScreenLocker::Delegate::Delegate() {}
+
+ScreenLocker::Delegate::~Delegate() {}
 
 //////////////////////////////////////////////////////////////////////////////
 // ScreenLocker, public:
 
 ScreenLocker::ScreenLocker(const user_manager::UserList& users)
     : users_(users), binding_(this), weak_factory_(this) {
   DCHECK(!screen_locker_);
   screen_locker_ = this;
 
   ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
   media::SoundsManager* manager = media::SoundsManager::Get();
   manager->Initialize(SOUND_LOCK,
                       bundle.GetRawDataResource(IDR_SOUND_LOCK_WAV));
   manager->Initialize(SOUND_UNLOCK,
                       bundle.GetRawDataResource(IDR_SOUND_UNLOCK_WAV));
   service_manager::Connector* connector =
       content::ServiceManagerConnection::GetForProcess()->GetConnector();
   connector->BindInterface(device::mojom::kServiceName, &fp_service_);
   fp_service_->AddFingerprintObserver(binding_.CreateInterfacePtrAndBind());
 }
 
 void ScreenLocker::Init() {
   input_method::InputMethodManager* imm =
       input_method::InputMethodManager::Get();
   saved_ime_state_ = imm->GetActiveIMEState();
   imm->SetState(saved_ime_state_->Clone());
 
   authenticator_ = UserSessionManager::GetInstance()->CreateAuthenticator(this);
   extended_authenticator_ = ExtendedAuthenticator::Create(this);
-  web_ui_.reset(new WebUIScreenLocker(this));
-  web_ui()->LockScreen();
+  if (IsUsingMdLogin()) {
+    // Create delegate that will eventually call into the views-based lock
+    // screen via mojo.
+    delegate_ = new StubDelegate();
+    owns_delegate_ = true;
 
-  // Ownership of |icon_image_source| is passed.
-  screenlock_icon_provider_.reset(new ScreenlockIconProvider);
-  ScreenlockIconSource* screenlock_icon_source =
-      new ScreenlockIconSource(screenlock_icon_provider_->AsWeakPtr());
-  content::URLDataSource::Add(web_ui()->GetWebContents()->GetBrowserContext(),
-                              screenlock_icon_source);
+    // Create and display lock screen.
+    // TODO(jdufualt): LockWindow should live in ash;
+    // ash::ShowLockScreenInWidget should be a mojo call.
+    LockWindow* lock_window = new LockWindow();
+    lock_window->SetBounds(
+        display::Screen::GetScreen()->GetPrimaryDisplay().bounds());
+    ash::ShowLockScreenInWidget(lock_window);
+  } else {
+    web_ui_.reset(new WebUIScreenLocker(this));
+    delegate_ = web_ui_.get();
+    owns_delegate_ = false;
+    web_ui_->LockScreen();
+
+    // Ownership of |icon_image_source| is passed.
+    screenlock_icon_provider_.reset(new ScreenlockIconProvider);
+    ScreenlockIconSource* screenlock_icon_source =
+        new ScreenlockIconSource(screenlock_icon_provider_->AsWeakPtr());
+    content::URLDataSource::Add(web_ui_->web_contents()->GetBrowserContext(),
+                                screenlock_icon_source);
+  }
 
   // Start locking on ash side.
   SessionControllerClient::Get()->StartLock(base::Bind(
       &ScreenLocker::OnStartLockCallback, weak_factory_.GetWeakPtr()));
 }
 
 void ScreenLocker::OnAuthFailure(const AuthFailure& error) {
   base::RecordAction(UserMetricsAction("ScreenLocker_OnLoginFailure"));
   if (authentication_start_time_.is_null()) {
     LOG(ERROR) << "Start time is not set at authentication failure";
   } else {
     base::TimeDelta delta = base::Time::Now() - authentication_start_time_;
     VLOG(1) << "Authentication failure: " << delta.InSecondsF() << " second(s)";
     UMA_HISTOGRAM_TIMES("ScreenLocker.AuthenticationFailureTime", delta);
   }
 
   UMA_HISTOGRAM_ENUMERATION("ScreenLocker.AuthenticationFailure",
                             unlock_attempt_type_, UnlockType::AUTH_COUNT);
 
   EnableInput();
   // Don't enable signout button here as we're showing
   // MessageBubble.
 
-  web_ui()->ShowErrorMessage(incorrect_passwords_count_++
-                                 ? IDS_LOGIN_ERROR_AUTHENTICATING_2ND_TIME
-                                 : IDS_LOGIN_ERROR_AUTHENTICATING,
-                             HelpAppLauncher::HELP_CANT_ACCESS_ACCOUNT);
+  delegate_->ShowErrorMessage(incorrect_passwords_count_++
+                                  ? IDS_LOGIN_ERROR_AUTHENTICATING_2ND_TIME
+                                  : IDS_LOGIN_ERROR_AUTHENTICATING,
+                              HelpAppLauncher::HELP_CANT_ACCESS_ACCOUNT);
 
   if (auth_status_consumer_)
     auth_status_consumer_->OnAuthFailure(error);
 }
 
 void ScreenLocker::OnAuthSuccess(const UserContext& user_context) {
   incorrect_passwords_count_ = 0;
   if (authentication_start_time_.is_null()) {
     if (user_context.GetAccountId().is_valid())
       LOG(ERROR) << "Start time is not set at authentication success";
   } else {
     base::TimeDelta delta = base::Time::Now() - authentication_start_time_;
     VLOG(1) << "Authentication success: " << delta.InSecondsF() << " second(s)";
     UMA_HISTOGRAM_TIMES("ScreenLocker.AuthenticationSuccessTime", delta);
   }
 
   UMA_HISTOGRAM_ENUMERATION("ScreenLocker.AuthenticationSuccess",
                             unlock_attempt_type_, UnlockType::AUTH_COUNT);
 
   const user_manager::User* user =
       user_manager::UserManager::Get()->FindUser(user_context.GetAccountId());
   if (user) {
     if (!user->is_active()) {
-      saved_ime_state_ = NULL;
+      saved_ime_state_ = nullptr;
       user_manager::UserManager::Get()->SwitchActiveUser(
           user_context.GetAccountId());
     }
 
     // Reset the number of PIN attempts available to the user. We always do this
     // because:
     // 1. If the user signed in with a PIN, that means they should be able to
     //    continue signing in with a PIN.
     // 2. If the user signed in with cryptohome keys, then the PIN timeout is
     //    going to be reset as well, so it is safe to reset the unlock attempt
@@ skipping 12 matching lines @@
 
   authentication_capture_.reset(new AuthenticationParametersCapture());
   authentication_capture_->user_context = user_context;
 
   // Add guard for case when something get broken in call chain to unlock
   // for sure.
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&ScreenLocker::UnlockOnLoginSuccess,
                             weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kUnlockGuardTimeoutMs));
-  web_ui()->AnimateAuthenticationSuccess();
+  delegate_->AnimateAuthenticationSuccess();
 }
 
 void ScreenLocker::OnPasswordAuthSuccess(const UserContext& user_context) {
   // The user has signed in using their password, so reset the PIN timeout.
   quick_unlock::QuickUnlockStorage* quick_unlock_storage =
       quick_unlock::QuickUnlockFactory::GetForAccountId(
           user_context.GetAccountId());
   if (quick_unlock_storage)
     quick_unlock_storage->MarkStrongAuth();
 }
@@ skipping 14 matching lines @@
 
   VLOG(1) << "Hiding the lock screen.";
   chromeos::ScreenLocker::Hide();
 }
 
 void ScreenLocker::Authenticate(const UserContext& user_context) {
   LOG_ASSERT(IsUserLoggedIn(user_context.GetAccountId()))
       << "Invalid user trying to unlock.";
 
   authentication_start_time_ = base::Time::Now();
-  web_ui()->SetInputEnabled(false);
+  delegate_->SetInputEnabled(false);
   if (user_context.IsUsingPin())
     unlock_attempt_type_ = AUTH_PIN;
 
   const user_manager::User* user = FindUnlockUser(user_context.GetAccountId());
   if (user) {
     // Check to see if the user submitted a PIN and it is valid.
     const std::string pin = user_context.GetKey()->GetSecret();
 
     // We only want to try authenticating the pin if it is a number,
     // otherwise we will timeout PIN if the user enters their account password
@@ skipping 43 matching lines @@
   return nullptr;
 }
 
 void ScreenLocker::OnStartLockCallback(bool locked) {
   // Happens in tests that exit with a pending lock. In real lock failure,
   // ash::LockStateController would cause the current user session to be
   // terminated.
   if (!locked)
     return;
 
-  web_ui()->OnAshLockAnimationFinished();
+  delegate_->OnAshLockAnimationFinished();
 
   AccessibilityManager::Get()->PlayEarcon(
       chromeos::SOUND_LOCK, PlaySoundOption::SPOKEN_FEEDBACK_ENABLED);
 }
 
 void ScreenLocker::ClearErrors() {
-  web_ui()->ClearErrors();
+  delegate_->ClearErrors();
 }
 
 void ScreenLocker::Signout() {
-  web_ui()->ClearErrors();
+  delegate_->ClearErrors();
   base::RecordAction(UserMetricsAction("ScreenLocker_Signout"));
   // We expect that this call will not wait for any user input.
   // If it changes at some point, we will need to force exit.
   chrome::AttemptUserExit();
 
   // Don't hide yet the locker because the chrome screen may become visible
   // briefly.
 }
 
 void ScreenLocker::EnableInput() {
-  web_ui()->SetInputEnabled(true);
+  delegate_->SetInputEnabled(true);
 }
 
 void ScreenLocker::ShowErrorMessage(int error_msg_id,
                                     HelpAppLauncher::HelpTopic help_topic_id,
                                     bool sign_out_only) {
-  web_ui()->SetInputEnabled(!sign_out_only);
-  web_ui()->ShowErrorMessage(error_msg_id, help_topic_id);
+  delegate_->SetInputEnabled(!sign_out_only);
+  delegate_->ShowErrorMessage(error_msg_id, help_topic_id);
 }
 
 void ScreenLocker::SetLoginStatusConsumer(
     chromeos::AuthStatusConsumer* consumer) {
   auth_status_consumer_ = consumer;
 }
 
 // static
 void ScreenLocker::InitClass() {
   DCHECK(!g_screen_lock_observer);
   g_screen_lock_observer = new ScreenLockObserver;
 }
 
 // static
 void ScreenLocker::ShutDownClass() {
   DCHECK(g_screen_lock_observer);
   delete g_screen_lock_observer;
-  g_screen_lock_observer = NULL;
+  g_screen_lock_observer = nullptr;
 }
 
 // static
 void ScreenLocker::HandleLockScreenRequest() {
   VLOG(1) << "Received LockScreen request from session manager";
   DCHECK(g_screen_lock_observer);
   if (UserAddingScreen::Get()->IsRunning()) {
     VLOG(1) << "Waiting for user adding screen to stop";
     UserAddingScreen::Get()->AddObserver(g_screen_lock_observer);
     UserAddingScreen::Get()->Cancel();
@@ skipping 65 matching lines @@
   }
 
   DCHECK(screen_locker_);
   SessionControllerClient::Get()->RunUnlockAnimation(
       base::Bind(&ScreenLocker::ScheduleDeletion));
 }
 
 // static
 void ScreenLocker::ScheduleDeletion() {
   // Avoid possible multiple calls.
-  if (screen_locker_ == NULL)
+  if (screen_locker_ == nullptr)
     return;
   VLOG(1) << "Deleting ScreenLocker " << screen_locker_;
 
   AccessibilityManager::Get()->PlayEarcon(
       SOUND_UNLOCK, PlaySoundOption::SPOKEN_FEEDBACK_ENABLED);
 
   delete screen_locker_;
-  screen_locker_ = NULL;
+  screen_locker_ = nullptr;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ScreenLocker, private:
 
 ScreenLocker::~ScreenLocker() {
   VLOG(1) << "Destroying ScreenLocker " << this;
   DCHECK(base::MessageLoopForUI::IsCurrent());
 
   if (authenticator_.get())
-    authenticator_->SetConsumer(NULL);
+    authenticator_->SetConsumer(nullptr);
   ClearErrors();
 
-  screen_locker_ = NULL;
+  screen_locker_ = nullptr;
   bool state = false;
   VLOG(1) << "Emitting SCREEN_LOCK_STATE_CHANGED with state=" << state;
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED,
       content::Source<ScreenLocker>(this),
       content::Details<bool>(&state));
 
   VLOG(1) << "Calling session manager's HandleLockScreenDismissed D-Bus method";
   DBusThreadManager::Get()->GetSessionManagerClient()->
       NotifyLockScreenDismissed();
 
   session_manager::SessionManager::Get()->SetSessionState(
       session_manager::SessionState::ACTIVE);
 
   if (saved_ime_state_.get()) {
     input_method::InputMethodManager::Get()->SetState(saved_ime_state_);
   }
+
+  if (owns_delegate_) {
+    owns_delegate_ = false;
+    delete delegate_;
+    delegate_ = nullptr;
+  }
 }
 
 void ScreenLocker::SetAuthenticator(Authenticator* authenticator) {
   authenticator_ = authenticator;
 }
 
 void ScreenLocker::ScreenLockReady() {
   locked_ = true;
   base::TimeDelta delta = base::Time::Now() - start_time_;
   VLOG(1) << "ScreenLocker " << this << " is ready after "
@@ skipping 44 matching lines @@
   if (scan_result != biod::ScanResult::SCAN_RESULT_SUCCESS) {
     OnFingerprintAuthFailure(*active_user);
     return;
   }
 
   UserContext user_context(active_user->GetAccountId());
   if (!base::ContainsKey(matches, active_user->username_hash())) {
     OnFingerprintAuthFailure(*active_user);
     return;
   }
-  web_ui()->SetFingerprintState(active_user->GetAccountId(),
-                                WebUIScreenLocker::FingerprintState::kSignin);
+  delegate_->SetFingerprintState(active_user->GetAccountId(),
+                                 FingerprintState::kSignin);
   OnAuthSuccess(user_context);
 }
 
 void ScreenLocker::OnSessionFailed() {
   LOG(ERROR) << "Fingerprint session failed.";
 }
 
 void ScreenLocker::OnFingerprintAuthFailure(const user_manager::User& user) {
   UMA_HISTOGRAM_ENUMERATION("ScreenLocker.AuthenticationFailure",
                             unlock_attempt_type_, UnlockType::AUTH_COUNT);
 
-  web_ui()->SetFingerprintState(user.GetAccountId(),
-                                WebUIScreenLocker::FingerprintState::kFailed);
+  delegate_->SetFingerprintState(user.GetAccountId(),
+                                 FingerprintState::kFailed);
 
   quick_unlock::QuickUnlockStorage* quick_unlock_storage =
       quick_unlock::QuickUnlockFactory::GetForUser(&user);
   if (quick_unlock_storage &&
       quick_unlock_storage->IsFingerprintAuthenticationAvailable()) {
     quick_unlock_storage->fingerprint_storage()->AddUnlockAttempt();
     if (quick_unlock_storage->fingerprint_storage()->ExceededUnlockAttempts()) {
-      web_ui()->SetFingerprintState(
-          user.GetAccountId(), WebUIScreenLocker::FingerprintState::kRemoved);
-      web_ui()->ShowErrorMessage(IDS_LOGIN_ERROR_FINGERPRINT_MAX_ATTEMPT,
-                                 HelpAppLauncher::HELP_CANT_ACCESS_ACCOUNT);
+      delegate_->SetFingerprintState(user.GetAccountId(),
+                                     FingerprintState::kRemoved);
+      delegate_->ShowErrorMessage(IDS_LOGIN_ERROR_FINGERPRINT_MAX_ATTEMPT,
+                                  HelpAppLauncher::HELP_CANT_ACCESS_ACCOUNT);
     }
   }
 
   if (auth_status_consumer_) {
     AuthFailure failure(AuthFailure::UNLOCK_FAILED);
     auth_status_consumer_->OnAuthFailure(failure);
   }
 }
 
 }  // namespace chromeos