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
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_POLICY_CORE_COMMON_POLICY_SERVICE_H_
#define COMPONENTS_POLICY_CORE_COMMON_POLICY_SERVICE_H_
#include <map>
#include <string>
#include "base/functional/callback.h"
#include "base/memory/raw_ptr.h"
#include "base/observer_list_types.h"
#include "base/scoped_observation_traits.h"
#include "build/build_config.h"
#include "components/policy/core/common/policy_map.h"
#include "components/policy/core/common/policy_namespace.h"
#include "components/policy/core/common/policy_types.h"
#include "components/policy/policy_export.h"
namespace policy {
class ConfigurationPolicyProvider;
#if BUILDFLAG(IS_ANDROID)
namespace android {
class PolicyServiceAndroid;
}
#endif
// The PolicyService merges policies from all available sources, taking into
// account their priorities. Policy clients can retrieve policy for their domain
// and register for notifications on policy updates.
//
// The PolicyService is available from BrowserProcess as a global singleton.
// There is also a PolicyService for browser-wide policies available from
// BrowserProcess as a global singleton.
class POLICY_EXPORT PolicyService {
public:
class POLICY_EXPORT Observer : public base::CheckedObserver {
public:
// Invoked whenever policies for the given |ns| namespace are modified.
// This is only invoked for changes that happen after AddObserver is called.
// |previous| contains the values of the policies before the update,
// and |current| contains the current values.
virtual void OnPolicyUpdated(const PolicyNamespace& ns,
const PolicyMap& previous,
const PolicyMap& current) {}
// Invoked at most once for each |domain|, when the PolicyService becomes
// ready. If IsInitializationComplete() is false, then this will be invoked
// once all the policy providers have finished loading their policies for
// |domain|. This does not handle failure to load policies from some
// providers, so it is possible for the policy service to be initialised
// if the providers failed for example to load its policies cache.
virtual void OnPolicyServiceInitialized(PolicyDomain domain) {}
// Invoked at most once for each |domain|, when the PolicyService becomes
// ready. If IsFirstPolicyLoadComplete() is false, then this will be invoked
// once all the policy providers have finished loading their policies for
// |domain|. The difference from |OnPolicyServiceInitialized| is that this
// will wait for cloud policies to be fetched when the local cache is not
// available, which may take some time depending on user's network.
virtual void OnFirstPoliciesLoaded(PolicyDomain domain) {}
};
class POLICY_EXPORT ProviderUpdateObserver : public base::CheckedObserver {
public:
// Invoked when the contents of a policy update signaled by |provider| are
// available through PolicyService::GetPolicies.
// This is intentionally also called if the policy update signaled by
// |provider| did not change the effective policy values. Note that multiple
// policy updates by |provider| can result in a single call to this
// function, e.g. if a subsequent policy update is signaled before the
// previous one has been processed by the PolicyService.
// Also note that when this is called, PolicyService's Observers may not
// have been called with the update that triggered this call yet.
virtual void OnProviderUpdatePropagated(
ConfigurationPolicyProvider* provider) = 0;
};
virtual ~PolicyService() = default;
// Observes changes to all components of the given |domain|.
virtual void AddObserver(PolicyDomain domain, Observer* observer) = 0;
virtual void RemoveObserver(PolicyDomain domain, Observer* observer) = 0;
// Observes propagation of policy updates by ConfigurationPolicyProviders.
virtual void AddProviderUpdateObserver(ProviderUpdateObserver* observer) = 0;
virtual void RemoveProviderUpdateObserver(
ProviderUpdateObserver* observer) = 0;
// Returns true if this PolicyService uses |provider| as one of its sources of
// policies.
virtual bool HasProvider(ConfigurationPolicyProvider* provider) const = 0;
virtual const PolicyMap& GetPolicies(const PolicyNamespace& ns) const = 0;
// The PolicyService loads policy from several sources, and some require
// asynchronous loads. IsInitializationComplete() returns true once all
// sources have been initialized for the given |domain|.
// It is safe to read policy from the PolicyService even if
// IsInitializationComplete() is false; there will be an OnPolicyUpdated()
// notification once new policies become available.
//
// OnPolicyServiceInitialized() is called when IsInitializationComplete()
// becomes true, which happens at most once for each domain.
// If IsInitializationComplete() is already true for |domain| when an Observer
// is registered, then that Observer will not receive an
// OnPolicyServiceInitialized() notification.
virtual bool IsInitializationComplete(PolicyDomain domain) const = 0;
// The PolicyService loads policy from several sources, and some require
// asynchronous loads. IsFirstPolicyLoadComplete() returns true once all
// sources have loaded their initial policies for the given |domain|.
// It is safe to read policy from the PolicyService even if
// IsFirstPolicyLoadComplete() is false; there will be an OnPolicyUpdated()
// notification once new policies become available.
//
// OnFirstPoliciesLoaded() is called when IsFirstPolicyLoadComplete()
// becomes true, which happens at most once for each domain.
// If IsFirstPolicyLoadComplete() is already true for |domain| when an
// Observer is registered, then that Observer will not receive an
// OnFirstPoliciesLoaded() notification.
virtual bool IsFirstPolicyLoadComplete(PolicyDomain domain) const = 0;
// Asks the PolicyService to reload policy from all available policy sources.
// |callback| is invoked once every source has reloaded its policies, and
// GetPolicies() is guaranteed to return the updated values at that point.
virtual void RefreshPolicies(base::OnceClosure callback,
PolicyFetchReason reason) = 0;
#if BUILDFLAG(IS_ANDROID)
// Get the PolicyService JNI bridge instance.
virtual android::PolicyServiceAndroid* GetPolicyServiceAndroid() = 0;
#endif
virtual void UseLocalTestPolicyProvider(
ConfigurationPolicyProvider* provider) = 0;
};
// A registrar that only observes changes to particular policies within the
// PolicyMap for the given policy namespace.
class POLICY_EXPORT PolicyChangeRegistrar : public PolicyService::Observer {
public:
typedef base::RepeatingCallback<void(const base::Value*, const base::Value*)>
UpdateCallback;
// Observes updates to the given (domain, component_id) namespace in the given
// |policy_service|, and notifies |observer| whenever any of the registered
// policy keys changes. Both the |policy_service| and the |observer| must
// outlive |this|.
PolicyChangeRegistrar(PolicyService* policy_service,
const PolicyNamespace& ns);
PolicyChangeRegistrar(const PolicyChangeRegistrar&) = delete;
PolicyChangeRegistrar& operator=(const PolicyChangeRegistrar&) = delete;
~PolicyChangeRegistrar() override;
// Will invoke |callback| whenever |policy_name| changes its value, as long
// as this registrar exists.
// Only one callback can be registed per policy name; a second call with the
// same |policy_name| will overwrite the previous callback.
void Observe(const std::string& policy_name, const UpdateCallback& callback);
// Implementation of PolicyService::Observer:
void OnPolicyUpdated(const PolicyNamespace& ns,
const PolicyMap& previous,
const PolicyMap& current) override;
private:
typedef std::map<std::string, UpdateCallback> CallbackMap;
raw_ptr<PolicyService> policy_service_;
PolicyNamespace ns_;
CallbackMap callback_map_;
};
} // namespace policy
namespace base {
template <>
struct ScopedObservationTraits<policy::PolicyService,
policy::PolicyService::ProviderUpdateObserver> {
static void AddObserver(
policy::PolicyService* source,
policy::PolicyService::ProviderUpdateObserver* observer) {
source->AddProviderUpdateObserver(observer);
}
static void RemoveObserver(
policy::PolicyService* source,
policy::PolicyService::ProviderUpdateObserver* observer) {
source->RemoveProviderUpdateObserver(observer);
}
};
} // namespace base
#endif // COMPONENTS_POLICY_CORE_COMMON_POLICY_SERVICE_H_
|
