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
|
// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/policy/core/common/proxy_policy_provider.h"
#include <memory>
#include <utility>
#include <variant>
#include "base/check_op.h"
#include "components/policy/core/common/policy_bundle.h"
namespace policy {
ProxyPolicyProvider::ProxyPolicyProvider() = default;
ProxyPolicyProvider::~ProxyPolicyProvider() {
DCHECK(!delegate());
}
void ProxyPolicyProvider::SetOwnedDelegate(OwnedDelegate delegate) {
ResetDelegate();
if (delegate) {
delegate_ = std::move(delegate);
}
OnDelegateChanged();
}
void ProxyPolicyProvider::SetUnownedDelegate(UnownedDelegate delegate) {
ResetDelegate();
if (delegate) {
delegate_ = delegate;
}
OnDelegateChanged();
}
void ProxyPolicyProvider::Shutdown() {
// Note: the delegate is not owned by the proxy provider, so this call is not
// forwarded. The same applies for the Init() call.
// Just drop the delegate without propagating updates here.
ResetDelegate();
ConfigurationPolicyProvider::Shutdown();
}
void ProxyPolicyProvider::RefreshPolicies(PolicyFetchReason reason) {
if (delegate()) {
delegate()->RefreshPolicies(reason);
} else {
// Subtle: if a RefreshPolicies() call comes after Shutdown() then the
// current bundle should be served instead. This also does the right thing
// if SetDelegate() was never called before.
UpdatePolicy(policies().Clone());
}
}
bool ProxyPolicyProvider::IsFirstPolicyLoadComplete(PolicyDomain domain) const {
return delegate() && delegate()->IsInitializationComplete(domain);
}
void ProxyPolicyProvider::OnUpdatePolicy(
ConfigurationPolicyProvider* provider) {
if (block_policy_updates_for_testing_)
return;
DCHECK_EQ(delegate(), provider);
UpdatePolicy(delegate()->policies().Clone());
}
ConfigurationPolicyProvider* ProxyPolicyProvider::delegate() {
return std::holds_alternative<OwnedDelegate>(delegate_)
? std::get<OwnedDelegate>(delegate_).get()
: std::get<UnownedDelegate>(delegate_).get();
}
const ConfigurationPolicyProvider* ProxyPolicyProvider::delegate() const {
return std::holds_alternative<OwnedDelegate>(delegate_)
? std::get<OwnedDelegate>(delegate_).get()
: std::get<UnownedDelegate>(delegate_).get();
}
void ProxyPolicyProvider::ResetDelegate() {
if (std::holds_alternative<OwnedDelegate>(delegate_)) {
std::get<OwnedDelegate>(delegate_)->Shutdown();
}
if (delegate()) {
delegate()->RemoveObserver(this);
}
delegate_ = UnownedDelegate(nullptr);
}
void ProxyPolicyProvider::OnDelegateChanged() {
if (delegate()) {
delegate()->AddObserver(this);
OnUpdatePolicy(delegate());
} else {
UpdatePolicy(PolicyBundle());
}
}
} // namespace policy
|
