ash: Merge LoginStatus update code path

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 {
 
@@ skipping 99 matching lines @@
     SessionStateObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void SessionController::RemoveSessionStateObserver(
     SessionStateObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 LoginStatus SessionController::GetLoginStatus() 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 GetLoginStatusForActiveSession();
-
-    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;
+  return login_status_;
 }
 
 void SessionController::SetClient(mojom::SessionControllerClientPtr client) {
   client_ = std::move(client);
 }
 
 void SessionController::SetSessionInfo(mojom::SessionInfoPtr info) {
   can_lock_ = info->can_lock_screen;
   should_lock_screen_automatically_ = info->should_lock_screen_automatically;
   add_user_session_policy_ = info->add_user_session_policy;
   SetSessionState(info->state);
 }
 
 void SessionController::UpdateUserSession(mojom::UserSessionPtr user_session) {
   auto it =
       std::find_if(user_sessions_.begin(), user_sessions_.end(),
                    [&user_session](const mojom::UserSessionPtr& session) {
                      return session->session_id == user_session->session_id;
                    });
   if (it == user_sessions_.end()) {
     AddUserSession(std::move(user_session));
     return;
   }
 
   *it = std::move(user_session);
   for (auto& observer : observers_)
     observer.UserSessionUpdated((*it)->account_id);
+
+  UpdateLoginStatus();
 }
 
 void SessionController::SetUserSessionOrder(
     const std::vector<uint32_t>& user_session_order) {
   DCHECK_EQ(user_sessions_.size(), user_session_order.size());
 
   // Adjusts |user_sessions_| to match the given order.
   std::vector<mojom::UserSessionPtr> sessions;
   for (const auto& session_id : user_session_order) {
     auto it =
         std::find_if(user_sessions_.begin(), user_sessions_.end(),
                      [session_id](const mojom::UserSessionPtr& session) {
                        return session && session->session_id == session_id;
                      });
     if (it == user_sessions_.end()) {
       LOG(ERROR) << "Unknown session id =" << session_id;
       continue;
     }
 
     sessions.push_back(std::move(*it));
   }
   user_sessions_.swap(sessions);
 
   // 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);
+
+    UpdateLoginStatus();
   }
 }
 
 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_);
+
+  UpdateLoginStatus();
 }
 
 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::GetLoginStatusForActiveSession() const {
+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);
 
   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:
@@ skipping 13 matching lines @@
       return LoginStatus::USER;
     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;
 }
 
+void SessionController::UpdateLoginStatus() {
+  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