1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_ASH_POLICY_STATUS_COLLECTOR_MANAGED_SESSION_SERVICE_H_
#define CHROME_BROWSER_ASH_POLICY_STATUS_COLLECTOR_MANAGED_SESSION_SERVICE_H_
#include "base/memory/raw_ptr.h"
#include "base/observer_list.h"
#include "base/observer_list_types.h"
#include "base/scoped_multi_source_observation.h"
#include "base/scoped_observation.h"
#include "base/sequence_checker.h"
#include "base/time/clock.h"
#include "base/time/default_clock.h"
#include "chrome/browser/ash/app_mode/kiosk_profile_load_failed_observer.h"
#include "chrome/browser/ash/login/session/user_session_manager.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/profiles/profile_observer.h"
#include "chromeos/ash/components/login/auth/auth_status_consumer.h"
#include "chromeos/ash/components/login/session/session_termination_manager.h"
#include "chromeos/dbus/power/power_manager_client.h"
#include "components/account_id/account_id.h"
#include "components/session_manager/core/session_manager_observer.h"
#include "components/user_manager/user_manager.h"
#include "components/user_manager/user_manager_impl.h"
namespace ash {
class UserSessionManager;
} // namespace ash
namespace session_manager {
class SessionManager;
} // namespace session_manager
namespace policy {
class ManagedSessionService : public ash::AuthStatusConsumer,
public ash::KioskProfileLoadFailedObserver,
public ash::SessionTerminationManager::Observer,
public ash::UserAuthenticatorObserver,
public chromeos::PowerManagerClient::Observer,
public ProfileObserver,
public session_manager::SessionManagerObserver,
public user_manager::UserManager::Observer {
public:
class Observer : public base::CheckedObserver {
public:
// Occurs when a user's login attempt fails.
virtual void OnLoginFailure(const ash::AuthFailure& error) {}
// Occurs when a user has logged in.
virtual void OnLogin(Profile* profile) {}
// Occurs when a user has logged out.
// TODO(b/194215634):: Check if this function can be replaced by
// `OnSessionTerminationStarted`
virtual void OnLogout(Profile* profile) {}
// Occurs when the active user has locked the user session.
virtual void OnLocked() {}
// TODO(b/247595531): Merge both Unlock functions into one.
// Occurs when the active user has unlocked the user session.
virtual void OnUnlocked() {}
// Occurs when the active user attempts to unlock the user session.
virtual void OnUnlockAttempt(
const bool success,
const session_manager::UnlockType unlock_type) {}
// Occurs when the device recovers from a suspend state, where
// |suspend_time| is the time when the suspend state
// first occurred. Short duration suspends are not reported.
virtual void OnResumeActive(base::Time suspend_time) {}
// Occurs in the beginning of the session termination process.
virtual void OnSessionTerminationStarted(const user_manager::User* user) {}
// Occurs just before a user's account will be removed.
virtual void OnUserToBeRemoved(const AccountId& account_id) {}
// Occurs after a user's account is removed.
virtual void OnUserRemoved(const AccountId& account_id,
user_manager::UserRemovalReason) {}
virtual void OnKioskLoginFailure() {}
};
explicit ManagedSessionService(
base::Clock* clock = base::DefaultClock::GetInstance());
ManagedSessionService(const ManagedSessionService&) = delete;
ManagedSessionService& operator=(const ManagedSessionService&) = delete;
~ManagedSessionService() override;
void AddObserver(Observer* observer);
void RemoveObserver(Observer* observer);
// session_manager::SessionManagerObserver::Observer
void OnSessionStateChanged() override;
void OnUserProfileLoaded(const AccountId& account_id) override;
void OnUnlockScreenAttempt(
const bool success,
const session_manager::UnlockType unlock_type) override;
// user_manager::Observer
void OnUserToBeRemoved(const AccountId& account_id) override;
void OnUserRemoved(const AccountId& account_id,
user_manager::UserRemovalReason reason) override;
// ProfileObserver
void OnProfileWillBeDestroyed(Profile* profile) override;
// chromeos::PowerManagerClient::Observer
void SuspendDone(base::TimeDelta sleep_duration) override;
void OnOnlinePasswordUnusable(std::unique_ptr<ash::UserContext> user_context,
bool) override {}
void OnPasswordChangeDetectedFor(const AccountId& account) override {}
void OnOldEncryptionDetected(std::unique_ptr<ash::UserContext> user_context,
bool has_incomplete_migration) override {}
void OnAuthSuccess(const ash::UserContext& user_context) override {}
void OnAuthFailure(const ash::AuthFailure& error) override;
void OnAuthAttemptStarted() override;
void OnSessionWillBeTerminated() override;
void OnKioskProfileLoadFailed() override;
private:
void SetLoginStatus();
bool is_session_locked_;
bool is_logged_in_observed_ = false;
raw_ptr<base::Clock> clock_;
base::ObserverList<Observer> observers_;
const raw_ptr<session_manager::SessionManager> session_manager_;
base::ScopedMultiSourceObservation<Profile, ProfileObserver>
profile_observations_{this};
base::ScopedObservation<session_manager::SessionManager,
session_manager::SessionManagerObserver>
session_manager_observation_{this};
base::ScopedObservation<chromeos::PowerManagerClient,
chromeos::PowerManagerClient::Observer>
power_manager_observation_{this};
base::ScopedObservation<ash::UserSessionManager,
ash::UserAuthenticatorObserver>
authenticator_observation_{this};
base::ScopedObservation<user_manager::UserManager,
user_manager::UserManager::Observer>
user_manager_observation_{this};
SEQUENCE_CHECKER(sequence_checker_);
};
} // namespace policy
#endif // CHROME_BROWSER_ASH_POLICY_STATUS_COLLECTOR_MANAGED_SESSION_SERVICE_H_
|
