cros: Pull user info from session_controller_client.mojom into separate mojom.

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 <utility>
 
+#include "ash/public/interfaces/user_info.mojom.h"
 #include "ash/session/session_observer.h"
 #include "ash/shell.h"
 #include "ash/system/power/power_event_observer.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 "components/user_manager/user_type.h"
@@ skipping 112 matching lines @@
   if (index < 0 || index >= static_cast<UserIndex>(user_sessions_.size()))
     return nullptr;
 
   return user_sessions_[index].get();
 }
 
 bool SessionController::IsUserSupervised() const {
   if (!IsActiveUserSessionStarted())
     return false;
 
-  user_manager::UserType active_user_type = GetUserSession(0)->type;
+  user_manager::UserType active_user_type = GetUserSession(0)->user_info->type;
   return active_user_type == user_manager::USER_TYPE_SUPERVISED ||
          active_user_type == user_manager::USER_TYPE_CHILD;
 }
 
 bool SessionController::IsUserChild() const {
   if (!IsActiveUserSessionStarted())
     return false;
 
-  user_manager::UserType active_user_type = GetUserSession(0)->type;
+  user_manager::UserType active_user_type = GetUserSession(0)->user_info->type;
   return active_user_type == user_manager::USER_TYPE_CHILD;
 }
 
 bool SessionController::IsKioskSession() const {
   if (!IsActiveUserSessionStarted())
     return false;
 
-  user_manager::UserType active_user_type = GetUserSession(0)->type;
+  user_manager::UserType active_user_type = GetUserSession(0)->user_info->type;
   return active_user_type == user_manager::USER_TYPE_KIOSK_APP ||
          active_user_type == user_manager::USER_TYPE_ARC_KIOSK_APP;
 }
 
 void SessionController::LockScreen() {
   if (client_)
     client_->RequestLockScreen();
 }
 
 void SessionController::SwitchActiveUser(const AccountId& account_id) {
@@ skipping 31 matching lines @@
                    [&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.OnUserSessionUpdated((*it)->account_id);
+    observer.OnUserSessionUpdated((*it)->user_info->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.OnActiveUserSessionChanged(user_sessions_[0]->account_id);
+    for (auto& observer : observers_) {
+      observer.OnActiveUserSessionChanged(
+          user_sessions_[0]->user_info->account_id);
+    }
 
     UpdateLoginStatus();
   }
 }
 
 void SessionController::StartLock(StartLockCallback callback) {
   DCHECK(start_lock_callback_.is_null());
   start_lock_callback_ = std::move(callback);
 
   LockStateController* const lock_state_controller =
@@ skipping 52 matching lines @@
   if (was_locked != locked) {
     if (!locked)
       is_unlocking_ = false;
 
     for (auto& observer : observers_)
       observer.OnLockStateChanged(locked);
   }
 }
 
 void SessionController::AddUserSession(mojom::UserSessionPtr user_session) {
-  const AccountId account_id(user_session->account_id);
+  const AccountId account_id(user_session->user_info->account_id);
 
   user_sessions_.push_back(std::move(user_session));
 
   for (auto& observer : observers_)
     observer.OnUserSessionAdded(account_id);
 }
 
 LoginStatus SessionController::CalculateLoginStatus() const {
   // 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
@@ skipping 17 matching lines @@
   NOTREACHED();
   return LoginStatus::NOT_LOGGED_IN;
 }
 
 LoginStatus SessionController::CalculateLoginStatusForActiveSession() const {
   DCHECK(state_ == SessionState::ACTIVE);
 
   if (user_sessions_.empty())  // Can be empty in tests.
     return LoginStatus::USER;
 
-  switch (user_sessions_[0]->type) {
+  switch (user_sessions_[0]->user_info->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;
     case user_manager::USER_TYPE_PUBLIC_ACCOUNT:
       return LoginStatus::PUBLIC;
     case user_manager::USER_TYPE_SUPERVISED:
       return LoginStatus::SUPERVISED;
     case user_manager::USER_TYPE_KIOSK_APP:
@@ skipping 23 matching lines @@
   for (auto& observer : observers_)
     observer.OnLoginStatusChanged(login_status_);
 }
 
 void SessionController::OnLockAnimationFinished() {
   if (!start_lock_callback_.is_null())
     std::move(start_lock_callback_).Run(true /* locked */);
 }
 
 }  // namespace ash