session_manager.cc 4.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146
  1. // Copyright 2014 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "components/session_manager/core/session_manager.h"
  5. #include <algorithm>
  6. #include "base/logging.h"
  7. #include "build/build_config.h"
  8. #include "components/session_manager/core/session_manager_observer.h"
  9. #include "components/user_manager/user_manager.h"
  10. namespace session_manager {
  11. // static
  12. SessionManager* SessionManager::instance = nullptr;
  13. SessionManager::SessionManager() {
  14. DCHECK(!SessionManager::Get());
  15. SessionManager::SetInstance(this);
  16. }
  17. SessionManager::~SessionManager() {
  18. DCHECK_EQ(instance, this);
  19. SessionManager::SetInstance(nullptr);
  20. }
  21. // static
  22. SessionManager* SessionManager::Get() {
  23. return SessionManager::instance;
  24. }
  25. void SessionManager::SetSessionState(SessionState state) {
  26. if (session_state_ == state)
  27. return;
  28. VLOG(1) << "Changing session state to: " << static_cast<int>(state);
  29. session_state_ = state;
  30. for (auto& observer : observers_)
  31. observer.OnSessionStateChanged();
  32. }
  33. void SessionManager::CreateSession(const AccountId& user_account_id,
  34. const std::string& user_id_hash,
  35. bool is_child) {
  36. CreateSessionInternal(user_account_id, user_id_hash,
  37. false /* browser_restart */, is_child);
  38. }
  39. void SessionManager::CreateSessionForRestart(const AccountId& user_account_id,
  40. const std::string& user_id_hash) {
  41. auto* user_manager = user_manager::UserManager::Get();
  42. if (!user_manager)
  43. return;
  44. const user_manager::User* user = user_manager->FindUser(user_account_id);
  45. // Tests do not always create users.
  46. const bool is_child =
  47. user && user->GetType() == user_manager::USER_TYPE_CHILD;
  48. CreateSessionInternal(user_account_id, user_id_hash,
  49. true /* browser_restart */, is_child);
  50. }
  51. bool SessionManager::IsSessionStarted() const {
  52. return session_started_;
  53. }
  54. void SessionManager::SessionStarted() {
  55. session_started_ = true;
  56. bool is_primary = sessions_.size() == 1;
  57. for (auto& observer : observers_)
  58. observer.OnUserSessionStarted(is_primary);
  59. }
  60. bool SessionManager::HasSessionForAccountId(
  61. const AccountId& user_account_id) const {
  62. return std::find_if(sessions_.begin(), sessions_.end(),
  63. [user_account_id](const Session& session) {
  64. return session.user_account_id == user_account_id;
  65. }) != sessions_.end();
  66. }
  67. bool SessionManager::IsInSecondaryLoginScreen() const {
  68. return session_state_ == SessionState::LOGIN_SECONDARY;
  69. }
  70. bool SessionManager::IsScreenLocked() const {
  71. return session_state_ == SessionState::LOCKED;
  72. }
  73. bool SessionManager::IsUserSessionBlocked() const {
  74. return session_state_ != SessionState::ACTIVE;
  75. }
  76. void SessionManager::AddObserver(SessionManagerObserver* observer) {
  77. observers_.AddObserver(observer);
  78. }
  79. void SessionManager::RemoveObserver(SessionManagerObserver* observer) {
  80. observers_.RemoveObserver(observer);
  81. }
  82. void SessionManager::NotifyUserProfileLoaded(const AccountId& account_id) {
  83. for (auto& observer : observers_)
  84. observer.OnUserProfileLoaded(account_id);
  85. }
  86. void SessionManager::NotifyNetworkErrorScreenShown() {
  87. for (auto& observer : observers_)
  88. observer.OnNetworkErrorScreenShown();
  89. }
  90. void SessionManager::NotifyLoginOrLockScreenVisible() {
  91. login_or_lock_screen_shown_for_test_ = true;
  92. for (auto& observer : observers_)
  93. observer.OnLoginOrLockScreenVisible();
  94. }
  95. void SessionManager::NotifyUserLoggedIn(const AccountId& user_account_id,
  96. const std::string& user_id_hash,
  97. bool browser_restart,
  98. bool is_child) {
  99. auto* user_manager = user_manager::UserManager::Get();
  100. if (!user_manager)
  101. return;
  102. user_manager->UserLoggedIn(user_account_id, user_id_hash, browser_restart,
  103. is_child);
  104. }
  105. // static
  106. void SessionManager::SetInstance(SessionManager* session_manager) {
  107. SessionManager::instance = session_manager;
  108. }
  109. void SessionManager::CreateSessionInternal(const AccountId& user_account_id,
  110. const std::string& user_id_hash,
  111. bool browser_restart,
  112. bool is_child) {
  113. DCHECK(!HasSessionForAccountId(user_account_id));
  114. sessions_.push_back({next_id_++, user_account_id});
  115. NotifyUserLoggedIn(user_account_id, user_id_hash, browser_restart, is_child);
  116. }
  117. } // namespace session_manager