Device policy infrastructure

chrome/browser/policy/cloud_policy_cache.cc

Index: chrome/browser/policy/cloud_policy_cache.cc
diff --git a/chrome/browser/policy/cloud_policy_cache.cc b/chrome/browser/policy/cloud_policy_cache.cc
index 37f0f7e834dec1cf26f8a454e2a8204123449f25..76c64669e9402ac13dc6bf002ae28ae3a67eb546 100644
--- a/chrome/browser/policy/cloud_policy_cache.cc
+++ b/chrome/browser/policy/cloud_policy_cache.cc
@@ -11,8 +11,8 @@
 #include "base/task.h"
 #include "base/values.h"
 #include "chrome/browser/browser_thread.h"
+#include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/policy/proto/cloud_policy.pb.h"
-#include "chrome/browser/policy/proto/device_management_backend.pb.h"
 #include "chrome/browser/policy/proto/device_management_constants.h"
 #include "chrome/browser/policy/proto/device_management_local.pb.h"
 
@@ -27,6 +27,51 @@ using google::protobuf::RepeatedPtrField;
 
 namespace policy {
 
+// A thin ConfigurationPolicyProvider implementation sitting on top of
+// CloudPolicyCache for hooking up with ConfigurationPolicyPrefStore.
+class CloudPolicyCache::CloudPolicyProvider
+    : public ConfigurationPolicyProvider {
+ public:
+  CloudPolicyProvider(const PolicyDefinitionList* policy_list,
+                      CloudPolicyCache* cache,
+                      CloudPolicyCache::PolicyLevel level)
+      : ConfigurationPolicyProvider(policy_list),
+        cache_(cache),
+        level_(level) {}
+  virtual ~CloudPolicyProvider() {}
+
+  virtual bool Provide(ConfigurationPolicyStoreInterface* store) {
+    if (cache_->has_device_policy()) {

[gfeher, 2011/02/14 17:28:50]

Shouldn't this be has_cloud_policy() ?

[Jakob Kummerow, 2011/02/21 12:12:15]

Done. Good catch!

+      if (level_ == POLICY_LEVEL_MANDATORY)
+        ApplyPolicyMap(&cache_->mandatory_policy_, store);
+      else if (level_ == POLICY_LEVEL_RECOMMENDED)
+        ApplyPolicyMap(&cache_->recommended_policy_, store);
+    } else {
+      ApplyPolicyValueTree(cache_->device_policy_.get(), store);
+    }
+    return true;
+  }
+
+  virtual bool IsInitializationComplete() const {
+    return cache_->initialization_complete_;
+  }
+
+  virtual void AddObserver(ConfigurationPolicyProvider::Observer* observer) {
+    cache_->observer_list_.AddObserver(observer);
+  }
+  virtual void RemoveObserver(ConfigurationPolicyProvider::Observer* observer) {
+    cache_->observer_list_.RemoveObserver(observer);
+  }
+
+ private:
+  // The underlying policy cache.
+  CloudPolicyCache* cache_;
+  // Policy level this provider will handle.
+  CloudPolicyCache::PolicyLevel level_;
+
+  DISALLOW_COPY_AND_ASSIGN(CloudPolicyProvider);
+};
+
 // Saves policy information to a file.
 class PersistPolicyTask : public Task {
  public:
@@ -79,17 +124,30 @@ CloudPolicyCache::CloudPolicyCache(
     const FilePath& backing_file_path)
     : backing_file_path_(backing_file_path),
       device_policy_(new DictionaryValue),
-      fresh_policy_(false),
+      initialization_complete_(false),
       is_unmanaged_(false),
       has_device_policy_(false) {
+  managed_policy_provider_.reset(
+      new CloudPolicyProvider(
+          ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList(),
+          this,
+          POLICY_LEVEL_MANDATORY));
+  recommended_policy_provider_.reset(
+      new CloudPolicyProvider(
+          ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList(),
+          this,
+          POLICY_LEVEL_RECOMMENDED));
 }
 
-CloudPolicyCache::~CloudPolicyCache() {}
+CloudPolicyCache::~CloudPolicyCache() {
+  FOR_EACH_OBSERVER(ConfigurationPolicyProvider::Observer,
+                    observer_list_, OnProviderGoingAway());
+}
 
-void CloudPolicyCache::LoadPolicyFromFile() {
+void CloudPolicyCache::LoadFromFile() {
   // TODO(jkummerow): This method is doing file IO during browser startup. In
   // the long run it would be better to delay this until the FILE thread exists.
-  if (!file_util::PathExists(backing_file_path_) || fresh_policy_) {
+  if (!file_util::PathExists(backing_file_path_) || initialization_complete_) {
     return;
   }
 
@@ -130,32 +188,25 @@ void CloudPolicyCache::LoadPolicyFromFile() {
     return;
   }
   // Swap in the new policy information.
-  if (is_unmanaged_) {
-    base::AutoLock lock(lock_);
-    last_policy_refresh_time_ = timestamp;
-    return;
-  } else if (cached_response.has_cloud_policy()) {
-    if (!fresh_policy_) {
-      base::AutoLock lock(lock_);
-      mandatory_policy_.swap(mandatory_policy);
-      recommended_policy_.swap(recommended_policy);
-      last_policy_refresh_time_ = timestamp;
-      has_device_policy_ = false;
-    }
+  if (cached_response.has_cloud_policy()) {
+    mandatory_policy_.swap(mandatory_policy);
+    recommended_policy_.swap(recommended_policy);
+    has_device_policy_ = false;
   } else if (cached_response.has_device_policy()) {
     scoped_ptr<DictionaryValue> value(
         DecodeDevicePolicy(cached_response.device_policy()));
-    if (!fresh_policy_) {
-      base::AutoLock lock(lock_);
-      device_policy_.reset(value.release());
-      last_policy_refresh_time_ = timestamp;
-      has_device_policy_ = true;
-    }
+    device_policy_.reset(value.release());
+    has_device_policy_ = true;
   }
+  last_policy_refresh_time_ = timestamp;
+  initialization_complete_ = true;
+
+  FOR_EACH_OBSERVER(ConfigurationPolicyProvider::Observer,
+                    observer_list_, OnUpdatePolicy());
 }
 
 bool CloudPolicyCache::SetPolicy(const em::CloudPolicyResponse& policy) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(CalledOnValidThread());
   is_unmanaged_ = false;
   base::Time timestamp;
   PolicyMapType mandatory_policy;
@@ -163,20 +214,20 @@ bool CloudPolicyCache::SetPolicy(const em::CloudPolicyResponse& policy) {
   bool ok = DecodePolicyResponse(policy, &mandatory_policy, &recommended_policy,
                                  &timestamp);
   if (!ok) {
-    // TODO(jkummerow): Signal error to PolicyProvider.
+    // TODO(jkummerow): Signal error to CloudPolicyController.
     return false;
   }
   const bool new_policy_differs =
       !Equals(mandatory_policy, mandatory_policy_) ||
       !Equals(recommended_policy, recommended_policy_);
-  {
-    base::AutoLock lock(lock_);
-    mandatory_policy_.swap(mandatory_policy);
-    recommended_policy_.swap(recommended_policy);
-    fresh_policy_ = true;
-    last_policy_refresh_time_ = timestamp;
-    has_device_policy_ = false;
-  }
+  mandatory_policy_.swap(mandatory_policy);
+  recommended_policy_.swap(recommended_policy);
+  initialization_complete_ = true;
+  last_policy_refresh_time_ = timestamp;
+  has_device_policy_ = false;
+
+  FOR_EACH_OBSERVER(ConfigurationPolicyProvider::Observer,
+                    observer_list_, OnUpdatePolicy());
 
   em::CloudPolicyResponse* policy_copy = new em::CloudPolicyResponse;
   policy_copy->CopyFrom(policy);
@@ -188,18 +239,18 @@ bool CloudPolicyCache::SetPolicy(const em::CloudPolicyResponse& policy) {
 }
 
 bool CloudPolicyCache::SetDevicePolicy(const em::DevicePolicyResponse& policy) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(CalledOnValidThread());
   is_unmanaged_ = false;
   DictionaryValue* value = DecodeDevicePolicy(policy);
   const bool new_policy_differs = !(value->Equals(device_policy_.get()));
   base::Time now(base::Time::NowFromSystemTime());
-  {
-    base::AutoLock lock(lock_);
-    device_policy_.reset(value);
-    fresh_policy_ = true;
-    last_policy_refresh_time_ = now;
-    has_device_policy_ = true;
-  }
+  device_policy_.reset(value);
+  initialization_complete_ = true;
+  last_policy_refresh_time_ = now;
+  has_device_policy_ = true;
+
+  FOR_EACH_OBSERVER(ConfigurationPolicyProvider::Observer,
+                    observer_list_, OnUpdatePolicy());
 
   em::DevicePolicyResponse* policy_copy = new em::DevicePolicyResponse;
   policy_copy->CopyFrom(policy);
@@ -210,34 +261,27 @@ bool CloudPolicyCache::SetDevicePolicy(const em::DevicePolicyResponse& policy) {
   return new_policy_differs;
 }
 
-DictionaryValue* CloudPolicyCache::GetDevicePolicy() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  base::AutoLock lock(lock_);
-  return device_policy_->DeepCopy();
+ConfigurationPolicyProvider* CloudPolicyCache::GetManagedPolicyProvider() {
+  DCHECK(CalledOnValidThread());
+  return managed_policy_provider_.get();
 }
 
-const CloudPolicyCache::PolicyMapType*
-    CloudPolicyCache::GetMandatoryPolicy() const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  return &mandatory_policy_;
-}
-
-const CloudPolicyCache::PolicyMapType*
-    CloudPolicyCache::GetRecommendedPolicy() const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  return &recommended_policy_;
+ConfigurationPolicyProvider* CloudPolicyCache::GetRecommendedPolicyProvider() {
+  DCHECK(CalledOnValidThread());
+  return recommended_policy_provider_.get();
 }
 
 void CloudPolicyCache::SetUnmanaged() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(CalledOnValidThread());
   is_unmanaged_ = true;
-  {
-    base::AutoLock lock(lock_);
-    mandatory_policy_.clear();
-    recommended_policy_.clear();
-    device_policy_.reset(new DictionaryValue);
-    last_policy_refresh_time_ = base::Time::NowFromSystemTime();
-  }
+  mandatory_policy_.clear();
+  recommended_policy_.clear();
+  device_policy_.reset(new DictionaryValue);
+  last_policy_refresh_time_ = base::Time::NowFromSystemTime();
+
+  FOR_EACH_OBSERVER(ConfigurationPolicyProvider::Observer,
+                    observer_list_, OnUpdatePolicy());
+
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,