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
168
169
170
171
172
173
174
175
|
// Copyright 2024 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_GLIC_GLIC_PROFILE_MANAGER_H_
#define CHROME_BROWSER_GLIC_GLIC_PROFILE_MANAGER_H_
#include "base/callback_list.h"
#include "base/memory/memory_pressure_monitor.h"
#include "base/memory/raw_ptr.h"
#include "base/observer_list_types.h"
#include "chrome/browser/glic/public/glic_keyed_service.h"
#include "chrome/browser/profiles/profile_manager_observer.h"
#include "services/network/public/cpp/network_connection_tracker.h"
class Profile;
namespace glic {
enum class GlicPrewarmingChecksResult;
// GlicProfileManager is a GlobalFeature that manages multi-profile Glic state.
// Among other things it is used for determining which profile to launch from an
// OS Entry point and ensuring that just one panel is shown across all profiles.
class GlicProfileManager : public ProfileManagerObserver {
public:
GlicProfileManager();
~GlicProfileManager() override;
class Observer : public base::CheckedObserver {
public:
virtual void OnLastActiveGlicProfileChanged(Profile* profile) = 0;
};
// Returns the global instance.
static GlicProfileManager* GetInstance();
GlicProfileManager(const GlicProfileManager&) = delete;
GlicProfileManager& operator=(const GlicProfileManager&) = delete;
// Return the profile that should be used to open glic. May be null if there
// is no eligible profile.
Profile* GetProfileForLaunch() const;
// Called by GlicKeyedService.
void SetActiveGlic(GlicKeyedService* glic);
// Called by GlicKeyedService.
void OnServiceShutdown(GlicKeyedService* glic);
// Called by GlobalFeatures.
void Shutdown();
// Called when the web client for the GlicWindowController or the FRE
// controller will be torn down.
void OnLoadingClientForService(GlicKeyedService* glic);
// Called by GlicWindowController and the GlicFreController when their
// respective web clients are being torn down.
void OnUnloadingClientForService(GlicKeyedService* glic);
// Callback will be invoked with kSuccess if the given profile should be
// considered for preloading.
using ShouldPreloadCallback =
base::OnceCallback<void(GlicPrewarmingChecksResult)>;
void ShouldPreloadForProfile(Profile* profile,
ShouldPreloadCallback callback);
// Callback will be invoked with true if the given profile should be
// considered for preloading the FRE.
void ShouldPreloadFreForProfile(Profile* profile,
base::OnceCallback<void(bool)> callback);
// Returns the active Glic service, nullptr if there is none.
GlicKeyedService* GetLastActiveGlic() const;
// Opens the panel if the "glic-open-on-startup" command line switch was used
// and glic has not already opened like this.
void MaybeAutoOpenGlicPanel();
void ShowProfilePicker();
void AddObserver(Observer* observer);
void RemoveObserver(Observer* observer);
bool IsShowing() const;
// ProfileManagerObserver:
void OnProfileMarkedForPermanentDeletion(Profile* profile) override;
// Static in order to permit setting forced values before the manager is
// constructed.
static void ForceProfileForLaunchForTesting(std::optional<Profile*> profile);
static void ForceMemoryPressureForTesting(
std::optional<base::MemoryPressureMonitor::MemoryPressureLevel> level);
static void ForceConnectionTypeForTesting(
std::optional<network::mojom::ConnectionType> type);
base::WeakPtr<GlicProfileManager> GetWeakPtr();
private:
// Callback from ProfilePicker::Show().
void DidSelectProfile(Profile* profile);
bool IsUnderMemoryPressure() const;
// Checks whether preloading is possible for the profile for either the fre
// or the glic panel (i.e., this excludes specific checks for those two
// surfaces).
void CanPreloadForProfile(Profile* profile, ShouldPreloadCallback callback);
bool IsLastActiveGlicProfile(Profile* profile) const;
bool IsLastLoadedGlicProfile(Profile* profile) const;
base::ObserverList<Observer> observers_;
base::WeakPtr<GlicKeyedService> last_active_glic_;
base::WeakPtr<GlicKeyedService> last_loaded_glic_;
bool did_auto_open_ = false;
base::WeakPtrFactory<GlicProfileManager> weak_ptr_factory_{this};
};
// These values are persisted to logs. Entries should not be renumbered and
// numeric values should never be reused. This enum should be kept in sync with
// GlicPrewarmingChecksResult in enums.xml.
// LINT.IfChange(GlicPrewarmingChecksResult)
enum class GlicPrewarmingChecksResult {
// Preloading is happening.
kSuccess = 0,
// Warming was disabled by the feature configuration.
kWarmingDisabled = 1,
// The profile doesn't exist or is marked for deletion.
kProfileGone = 2,
// The profile is not ready for Glic, for an unknown reason.
kProfileNotReadyUnknown = 3,
// The account state is paused, and requires sign in.
kProfileRequiresSignIn = 4,
// The profile is not eligible for Glic.
kProfileNotEligible = 5,
// Glic is not rolled out to the user.
kProfileNotRolledOut = 6,
// The profile is disallowed by admin policy.
kProfileDisallowedByAdmin = 7,
// The profile is not enabled for Glic for some other reason.
kProfileNotEnabledOther = 8,
// The profile is already the last loaded profile.
kProfileIsLastLoaded = 9,
// The profile is already the last active profile.
kProfileIsLastActive = 10,
// Preloading is blocked because another Glic is already showing.
kBlockedByShownGlic = 11,
// The system is under memory pressure.
kUnderMemoryPressure = 12,
// The device has a cellular connection.
kCellularConnection = 13,
kMaxValue = kCellularConnection,
};
// LINT.ThenChange(//tools/metrics/histograms/metadata/glic/enums.xml:GlicPrewarmingChecksResult)
} // namespace glic
#endif // CHROME_BROWSER_GLIC_GLIC_PROFILE_MANAGER_H_
|
