ash: Use SessionController instead of SessionStateDelegate

ash/common/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/common/session/session_controller.h"
 
 #include <algorithm>
 
 #include "ash/common/login_status.h"
 #include "ash/common/session/session_state_observer.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"
 
 namespace ash {
 
-SessionController::SessionController() {}
+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() {
+  const bool start_with_user =
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
+          chromeos::switches::kLoginUser);
+  return start_with_user ? session_manager::SessionState::ACTIVE
+                         : session_manager::SessionState::UNKNOWN;
+}
+
+}  // namespace
+
+SessionController::SessionController() : state_(GetDefaultSessionState()) {}
 
 SessionController::~SessionController() {}
 
 void SessionController::BindRequest(mojom::SessionControllerRequest request) {
   bindings_.AddBinding(this, std::move(request));
 }
 
 int SessionController::GetMaximumNumberOfLoggedInUsers() const {
   return session_manager::kMaxmiumNumberOfUserSessions;
 }
 
 int SessionController::NumberOfLoggedInUsers() const {
   return static_cast<int>(user_sessions_.size());
 }
 
 AddUserSessionPolicy SessionController::GetAddUserPolicy() const {
   return add_user_session_policy_;
 }
 
 bool SessionController::IsActiveUserSessionStarted() const {
   return !user_sessions_.empty();
 }
 
 bool SessionController::CanLockScreen() const {
-  return can_lock_;
+  return IsActiveUserSessionStarted() && can_lock_;
 }
 
 bool SessionController::IsScreenLocked() const {
   return state_ == session_manager::SessionState::LOCKED;
 }
 
 bool SessionController::ShouldLockScreenAutomatically() const {
   return should_lock_screen_automatically_;
 }
 
 bool SessionController::IsUserSessionBlocked() const {
   return state_ != session_manager::SessionState::ACTIVE;
 }
 
+bool SessionController::IsInSecondaryLoginScreen() const {
+  return state_ == session_manager::SessionState::LOGIN_SECONDARY;
+}
+
 session_manager::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 {
+  if (index < 0 || index >= static_cast<UserIndex>(user_sessions_.size()))
+    return nullptr;
+
+  return user_sessions_[index].get();
+}
+
 void SessionController::LockScreen() {
   if (client_)
     client_->RequestLockScreen();
 }
 
 void SessionController::SwitchActiveUser(const AccountId& account_id) {
   if (client_)
     client_->SwitchActiveUser(account_id);
 }
 
@@ skipping 88 matching lines @@
 
   // Check active user change and notifies observers.
   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);
   }
 }
 
+void SessionController::ClearUserSessionsForTest() {
+  user_sessions_.clear();
+}
+
+void SessionController::FlushMojoForTest() {
+  client_.FlushForTesting();
+}
+
+void SessionController::LockScreenAndFlushForTest() {
+  LockScreen();
+  FlushMojoForTest();
+}
+
 void SessionController::SetSessionState(session_manager::SessionState state) {
   if (state_ == state)
     return;
 
   state_ = state;
   for (auto& observer : observers_)
     observer.SessionStateChanged(state_);
 }
 
 void SessionController::AddUserSession(mojom::UserSessionPtr user_session) {
@@ skipping 33 matching lines @@
     case user_manager::NUM_USER_TYPES:
       // Avoid having a "default" case so the compiler catches new enum values.
       NOTREACHED();
       return LoginStatus::USER;
   }
   NOTREACHED();
   return LoginStatus::USER;
 }
 
 }  // namespace ash