OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #ifndef CHROME_BROWSER_POLICY_CLOUD_CLOUD_POLICY_STORE_H_ | |
6 #define CHROME_BROWSER_POLICY_CLOUD_CLOUD_POLICY_STORE_H_ | |
7 | |
8 #include "base/basictypes.h" | |
9 #include "base/memory/scoped_ptr.h" | |
10 #include "base/memory/weak_ptr.h" | |
11 #include "base/observer_list.h" | |
12 #include "chrome/browser/policy/cloud/cloud_policy_validator.h" | |
13 #include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h" | |
14 #include "components/policy/core/common/policy_map.h" | |
15 | |
16 namespace policy { | |
17 | |
18 class CloudExternalDataManager; | |
19 | |
20 // Defines the low-level interface used by the cloud policy code to: | |
21 // 1. Validate policy blobs that should be applied locally | |
22 // 2. Persist policy blobs | |
23 // 3. Decode policy blobs to PolicyMap representation | |
24 class CloudPolicyStore { | |
25 public: | |
26 // Status codes. | |
27 enum Status { | |
28 // Everything is in good order. | |
29 STATUS_OK, | |
30 // Loading policy from the underlying data store failed. | |
31 STATUS_LOAD_ERROR, | |
32 // Failed to store policy to the data store. | |
33 STATUS_STORE_ERROR, | |
34 // Failed to parse the policy read from the data store. | |
35 STATUS_PARSE_ERROR, | |
36 // Failed to serialize policy for storage. | |
37 STATUS_SERIALIZE_ERROR, | |
38 // Validation error. | |
39 STATUS_VALIDATION_ERROR, | |
40 // Store cannot accept policy (e.g. non-enterprise device). | |
41 STATUS_BAD_STATE, | |
42 }; | |
43 | |
44 // Callbacks for policy store events. Most importantly, policy updates. | |
45 class Observer { | |
46 public: | |
47 virtual ~Observer(); | |
48 | |
49 // Called on changes to store->policy() and/or store->policy_map(). | |
50 virtual void OnStoreLoaded(CloudPolicyStore* store) = 0; | |
51 | |
52 // Called upon encountering errors. | |
53 virtual void OnStoreError(CloudPolicyStore* store) = 0; | |
54 }; | |
55 | |
56 CloudPolicyStore(); | |
57 virtual ~CloudPolicyStore(); | |
58 | |
59 // Indicates whether the store has been fully initialized. This is | |
60 // accomplished by calling Load() after startup. | |
61 bool is_initialized() const { return is_initialized_; } | |
62 | |
63 base::WeakPtr<CloudExternalDataManager> external_data_manager() const { | |
64 return external_data_manager_; | |
65 } | |
66 | |
67 const PolicyMap& policy_map() const { return policy_map_; } | |
68 bool has_policy() const { | |
69 return policy_.get() != NULL; | |
70 } | |
71 const enterprise_management::PolicyData* policy() const { | |
72 return policy_.get(); | |
73 } | |
74 bool is_managed() const { | |
75 return policy_.get() && | |
76 policy_->state() == enterprise_management::PolicyData::ACTIVE; | |
77 } | |
78 Status status() const { return status_; } | |
79 CloudPolicyValidatorBase::Status validation_status() const { | |
80 return validation_status_; | |
81 } | |
82 | |
83 // Store a new policy blob. Pending load/store operations will be canceled. | |
84 // The store operation may proceed asynchronously and observers are notified | |
85 // once the operation finishes. If successful, OnStoreLoaded() will be invoked | |
86 // on the observers and the updated policy can be read through policy(). | |
87 // Errors generate OnStoreError() notifications. | |
88 // |invalidation_version| is the invalidation version of the policy to be | |
89 // stored. | |
90 void Store( | |
91 const enterprise_management::PolicyFetchResponse& policy, | |
92 int64 invalidation_version); | |
93 | |
94 virtual void Store( | |
95 const enterprise_management::PolicyFetchResponse& policy) = 0; | |
96 | |
97 // Load the current policy blob from persistent storage. Pending load/store | |
98 // operations will be canceled. This may trigger asynchronous operations. | |
99 // Upon success, OnStoreLoaded() will be called on the registered observers. | |
100 // Otherwise, OnStoreError() reports the reason for failure. | |
101 virtual void Load() = 0; | |
102 | |
103 // Registers an observer to be notified when policy changes. | |
104 void AddObserver(Observer* observer); | |
105 | |
106 // Removes the specified observer. | |
107 void RemoveObserver(Observer* observer); | |
108 | |
109 // The invalidation version of the last policy stored. This value can be read | |
110 // by observers to determine which version of the policy is now available. | |
111 int64 invalidation_version() { | |
112 return invalidation_version_; | |
113 } | |
114 | |
115 // Indicate that external data referenced by policies in this store is managed | |
116 // by |external_data_manager|. The |external_data_manager| will be notified | |
117 // about policy changes before any other observers. | |
118 void SetExternalDataManager( | |
119 base::WeakPtr<CloudExternalDataManager> external_data_manager); | |
120 | |
121 // Replaces |policy_map_| and calls the registered observers, simulating a | |
122 // successful load of |policy_map| from persistent storage. | |
123 // TODO(bartfab): This override is only needed because there are no policies | |
124 // that reference external data and therefore, no ExternalDataFetchers in the | |
125 // |policy_map_|. Once the first such policy is added, use that policy in | |
126 // tests and remove the override. | |
127 void SetPolicyMapForTesting(const PolicyMap& policy_map); | |
128 | |
129 protected: | |
130 // Invokes the corresponding callback on all registered observers. | |
131 void NotifyStoreLoaded(); | |
132 void NotifyStoreError(); | |
133 | |
134 // Manages external data referenced by policies. | |
135 base::WeakPtr<CloudExternalDataManager> external_data_manager_; | |
136 | |
137 // Decoded version of the currently effective policy. | |
138 PolicyMap policy_map_; | |
139 | |
140 // Currently effective policy. | |
141 scoped_ptr<enterprise_management::PolicyData> policy_; | |
142 | |
143 // Latest status code. | |
144 Status status_; | |
145 | |
146 // Latest validation status. | |
147 CloudPolicyValidatorBase::Status validation_status_; | |
148 | |
149 // The invalidation version of the last policy stored. | |
150 int64 invalidation_version_; | |
151 | |
152 private: | |
153 // Whether the store has completed asynchronous initialization, which is | |
154 // triggered by calling Load(). | |
155 bool is_initialized_; | |
156 | |
157 ObserverList<Observer, true> observers_; | |
158 | |
159 DISALLOW_COPY_AND_ASSIGN(CloudPolicyStore); | |
160 }; | |
161 | |
162 } // namespace policy | |
163 | |
164 #endif // CHROME_BROWSER_POLICY_CLOUD_CLOUD_POLICY_STORE_H_ | |
OLD | NEW |