blob: 5f565895d63a84d17767d0e87ca9c3a5c324366a (
plain)
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
|
// Copyright 2013 The Chromium Authors. All rights reserved.
// 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_SCHEMA_REGISTRY_H_
#define COMPONENTS_POLICY_CORE_COMMON_SCHEMA_REGISTRY_H_
#include <set>
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/memory/ref_counted.h"
#include "base/observer_list.h"
#include "base/threading/non_thread_safe.h"
#include "components/policy/core/common/policy_namespace.h"
#include "components/policy/core/common/schema.h"
#include "components/policy/core/common/schema_map.h"
namespace policy {
class SchemaMap;
// Holds the main reference to the current SchemaMap, and allows a list of
// observers to get notified whenever it is updated.
// This object is not thread safe and must be used from the owner's thread,
// usually UI.
class POLICY_EXPORT SchemaRegistry : public base::NonThreadSafe {
public:
class POLICY_EXPORT Observer {
public:
// Invoked whenever schemas are registered or unregistered.
// |has_new_schemas| is true if a new component has been registered since
// the last update; this allows observers to ignore updates when
// components are unregistered but still get a handle to the current map
// (e.g. for periodic reloads).
virtual void OnSchemaRegistryUpdated(bool has_new_schemas) = 0;
// Invoked when all policy domains become ready.
virtual void OnSchemaRegistryReady() = 0;
protected:
virtual ~Observer();
};
SchemaRegistry();
virtual ~SchemaRegistry();
const scoped_refptr<SchemaMap>& schema_map() const { return schema_map_; }
// Register a single component.
void RegisterComponent(const PolicyNamespace& ns,
const Schema& schema);
// Register a list of components for a given domain.
virtual void RegisterComponents(PolicyDomain domain,
const ComponentMap& components);
virtual void UnregisterComponent(const PolicyNamespace& ns);
// Returns true if all domains have registered the initial components.
bool IsReady() const;
// This indicates that the initial components for |domain| have all been
// registered. It must be invoked at least once for each policy domain;
// subsequent calls for the same domain are ignored.
void SetReady(PolicyDomain domain);
void AddObserver(Observer* observer);
void RemoveObserver(Observer* observer);
bool HasObservers() const;
protected:
void Notify(bool has_new_schemas);
scoped_refptr<SchemaMap> schema_map_;
private:
ObserverList<Observer, true> observers_;
bool domains_ready_[POLICY_DOMAIN_SIZE];
DISALLOW_COPY_AND_ASSIGN(SchemaRegistry);
};
// A registry that combines the maps of other registries.
class POLICY_EXPORT CombinedSchemaRegistry : public SchemaRegistry,
public SchemaRegistry::Observer {
public:
CombinedSchemaRegistry();
virtual ~CombinedSchemaRegistry();
void Track(SchemaRegistry* registry);
void Untrack(SchemaRegistry* registry);
virtual void RegisterComponents(PolicyDomain domain,
const ComponentMap& components) OVERRIDE;
virtual void UnregisterComponent(const PolicyNamespace& ns) OVERRIDE;
virtual void OnSchemaRegistryUpdated(bool has_new_schemas) OVERRIDE;
virtual void OnSchemaRegistryReady() OVERRIDE;
private:
void Combine(bool has_new_schemas);
std::set<SchemaRegistry*> registries_;
scoped_refptr<SchemaMap> own_schema_map_;
DISALLOW_COPY_AND_ASSIGN(CombinedSchemaRegistry);
};
} // namespace policy
#endif // COMPONENTS_POLICY_CORE_COMMON_SCHEMA_REGISTRY_H_
|
