mash: Run pre-unlock animation via SessionController

ash/session/session_controller.cc

 // Copyright 2016 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 "ash/session/session_controller.h"
 
 #include <algorithm>
 
 #include "ash/session/session_state_observer.h"
+#include "ash/shell.h"
+#include "ash/wm/lock_state_controller.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "chromeos/chromeos_switches.h"
 #include "components/signin/core/account_id/account_id.h"
 #include "services/service_manager/public/cpp/connector.h"
 
+using session_manager::SessionState;
+
 namespace ash {
 
 namespace {
 
 // Get the default session state. Default session state is ACTIVE when the
 // process starts with a user session, i.e. the process has kLoginUser command
 // line switch. This is needed because ash focus rules depends on whether
 // session is blocked to pick an activatable window and chrome needs to create a
 // focused browser window when starting with a user session (both in production
 // and in tests). Using ACTIVE as default in this situation allows chrome to run
 // without having to wait for session state to reach to ash. For other cases
 // (oobe/login), there is only one login window. The login window always gets
 // focus so default session state does not matter. Use UNKNOWN and wait for
 // chrome to update ash for such cases.
-session_manager::SessionState GetDefaultSessionState() {
+SessionState GetDefaultSessionState() {
   const bool start_with_user =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           chromeos::switches::kLoginUser);
-  return start_with_user ? session_manager::SessionState::ACTIVE
-                         : session_manager::SessionState::UNKNOWN;
+  return start_with_user ? SessionState::ACTIVE : SessionState::UNKNOWN;
 }
 
 }  // namespace
 
 SessionController::SessionController() : state_(GetDefaultSessionState()) {}
 
 SessionController::~SessionController() {}
 
 void SessionController::BindRequest(mojom::SessionControllerRequest request) {
   bindings_.AddBinding(this, std::move(request));
@@ skipping 13 matching lines @@
 
 bool SessionController::IsActiveUserSessionStarted() const {
   return !user_sessions_.empty();
 }
 
 bool SessionController::CanLockScreen() const {
   return IsActiveUserSessionStarted() && can_lock_;
 }
 
 bool SessionController::IsScreenLocked() const {
-  return state_ == session_manager::SessionState::LOCKED;
+  return state_ == SessionState::LOCKED;
 }
 
 bool SessionController::ShouldLockScreenAutomatically() const {
   return should_lock_screen_automatically_;
 }
 
 bool SessionController::IsUserSessionBlocked() const {
-  return state_ != session_manager::SessionState::ACTIVE;
+  // User sessions are blocked when session state is not ACTIVE, except that
+  // LOCKED state with a running unlocking animation. This is made an exception
+  // because the unlocking animation hides lock container at the end. During the
+  // unlock animation, IsUserSessionBlocked needs to return unblocked so that
+  // user windows are deemed activatable and ash correctly restore the active
+  // window before locking.
+  return state_ != SessionState::ACTIVE &&
+         !(state_ == SessionState::LOCKED && is_unlocking_);
 }
 
 bool SessionController::IsInSecondaryLoginScreen() const {
-  return state_ == session_manager::SessionState::LOGIN_SECONDARY;
+  return state_ == SessionState::LOGIN_SECONDARY;
 }
 
-session_manager::SessionState SessionController::GetSessionState() const {
+SessionState SessionController::GetSessionState() const {
   return state_;
 }
 
 const std::vector<mojom::UserSessionPtr>& SessionController::GetUserSessions()
     const {
   return user_sessions_;
 }
 
 const mojom::UserSession* SessionController::GetUserSession(
     UserIndex index) const {
@@ skipping 82 matching lines @@
   if (user_sessions_[0]->session_id != active_session_id_) {
     active_session_id_ = user_sessions_[0]->session_id;
 
     for (auto& observer : observers_)
       observer.ActiveUserChanged(user_sessions_[0]->account_id);
 
     UpdateLoginStatus();
   }
 }
 
+void SessionController::RunUnlockAnimation(
+    const RunUnlockAnimationCallback& callback) {
+  is_unlocking_ = true;
+
+  // Shell could have no instance in tests.
+  if (Shell::HasInstance())
+    Shell::Get()->lock_state_controller()->OnLockScreenHide(callback);
+}
+
 void SessionController::ClearUserSessionsForTest() {
   user_sessions_.clear();
 }
 
 void SessionController::FlushMojoForTest() {
   client_.FlushForTesting();
 }
 
 void SessionController::LockScreenAndFlushForTest() {
   LockScreen();
   FlushMojoForTest();
 }
 
-void SessionController::SetSessionState(session_manager::SessionState state) {
+void SessionController::SetSessionState(SessionState state) {
   if (state_ == state)
     return;
 
+  const bool was_locked = state_ == SessionState::LOCKED;
   state_ = state;
   for (auto& observer : observers_)
     observer.SessionStateChanged(state_);
 
   UpdateLoginStatus();
+
+  const bool locked = state_ == SessionState::LOCKED;
+  if (was_locked != locked) {
+    if (!locked)
+      is_unlocking_ = false;
+
+    for (auto& observer : observers_)
+      observer.LockStateChanged(locked);
+  }
 }
 
 void SessionController::AddUserSession(mojom::UserSessionPtr user_session) {
   const AccountId account_id(user_session->account_id);
 
   user_sessions_.push_back(std::move(user_session));
 
   for (auto& observer : observers_)
     observer.UserAddedToSession(account_id);
 }
 
 LoginStatus SessionController::CalculateLoginStatus() const {
-  using session_manager::SessionState;
-
   // TODO(jamescook|xiyuan): There is not a 1:1 mapping of SessionState to
   // LoginStatus. Fix the cases that don't match. http://crbug.com/701193
   switch (state_) {
     case SessionState::UNKNOWN:
     case SessionState::OOBE:
     case SessionState::LOGIN_PRIMARY:
     case SessionState::LOGGED_IN_NOT_ACTIVE:
       return LoginStatus::NOT_LOGGED_IN;
 
     case SessionState::ACTIVE:
       return CalculateLoginStatusForActiveSession();
 
     case SessionState::LOCKED:
       return LoginStatus::LOCKED;
 
     case SessionState::LOGIN_SECONDARY:
       // TODO: There is no LoginStatus for this.
       return LoginStatus::USER;
   }
   NOTREACHED();
   return LoginStatus::NOT_LOGGED_IN;
 }
 
 LoginStatus SessionController::CalculateLoginStatusForActiveSession() const {
-  DCHECK(state_ == session_manager::SessionState::ACTIVE);
+  DCHECK(state_ == SessionState::ACTIVE);
 
   if (user_sessions_.empty())  // Can be empty in tests.
     return LoginStatus::USER;
 
   switch (user_sessions_[0]->type) {
     case user_manager::USER_TYPE_REGULAR:
       // TODO: This needs to distinguish between owner and non-owner.
       return LoginStatus::USER;
     case user_manager::USER_TYPE_GUEST:
       return LoginStatus::GUEST;
@@ skipping 23 matching lines @@
   const LoginStatus new_login_status = CalculateLoginStatus();
   if (new_login_status == login_status_)
     return;
 
   login_status_ = new_login_status;
   for (auto& observer : observers_)
     observer.LoginStatusChanged(login_status_);
 }
 
 }  // namespace ash