| 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 |