Move user cloud policy to BrowserProcess.

chrome/browser/policy/cloud_policy_cache_base.cc

 // Copyright (c) 2011 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.
 
 #include "chrome/browser/policy/cloud_policy_cache_base.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/values.h"
-#include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/policy/policy_notifier.h"
 
 namespace policy {
 
-// A thin ConfigurationPolicyProvider implementation sitting on top of
-// CloudPolicyCacheBase for hooking up with ConfigurationPolicyPrefStore.
-class CloudPolicyCacheBase::CloudPolicyProvider
-    : public ConfigurationPolicyProvider {
- public:
-  CloudPolicyProvider(const PolicyDefinitionList* policy_list,
-                      CloudPolicyCacheBase* cache,
-                      CloudPolicyCacheBase::PolicyLevel level)
-      : ConfigurationPolicyProvider(policy_list),
-        cache_(cache),
-        level_(level) {}
-  virtual ~CloudPolicyProvider() {}
-
-  virtual bool Provide(ConfigurationPolicyStoreInterface* store) {
-    if (level_ == POLICY_LEVEL_MANDATORY)
-      ApplyPolicyMap(&cache_->mandatory_policy_, store);
-    else if (level_ == POLICY_LEVEL_RECOMMENDED)
-      ApplyPolicyMap(&cache_->recommended_policy_, 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.
-  CloudPolicyCacheBase* cache_;
-  // Policy level this provider will handle.
-  CloudPolicyCacheBase::PolicyLevel level_;
-
-  DISALLOW_COPY_AND_ASSIGN(CloudPolicyProvider);
-};
-
 CloudPolicyCacheBase::CloudPolicyCacheBase()
     : notifier_(NULL),
       initialization_complete_(false),
       is_unmanaged_(false) {
   public_key_version_.valid = 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));
 }
 
 CloudPolicyCacheBase::~CloudPolicyCacheBase() {
-  FOR_EACH_OBSERVER(ConfigurationPolicyProvider::Observer,
-                    observer_list_, OnProviderGoingAway());
+  FOR_EACH_OBSERVER(Observer, observer_list_, OnCacheGoingAway(this));
+}
+
+void CloudPolicyCacheBase::AddObserver(Observer* observer) {
+  observer_list_.AddObserver(observer);
+}
+
+void CloudPolicyCacheBase::RemoveObserver(Observer* observer) {
+  observer_list_.RemoveObserver(observer);
+}
+
+const PolicyMap* CloudPolicyCacheBase::policy(PolicyLevel level) {
+  if (level==POLICY_LEVEL_MANDATORY)

[Mattias Nissler (ping if slow), 2011/06/09 14:36:26]

make it a switch?

[sfeuz, 2011/06/13 06:53:53]

Done.

+    return mandatory_policy();
+  else if (level==POLICY_LEVEL_RECOMMENDED)
+    return recommended_policy();
+  NOTREACHED();
+  return NULL;
+}
+
+const PolicyMap* CloudPolicyCacheBase::mandatory_policy() {
+  return &mandatory_policy_;
+}
+
+const PolicyMap* CloudPolicyCacheBase::recommended_policy() {
+  return &recommended_policy_;
 }
 
 bool CloudPolicyCacheBase::GetPublicKeyVersion(int* version) {
   if (public_key_version_.valid)
     *version = public_key_version_.version;
 
   return public_key_version_.valid;
 }
 
 bool CloudPolicyCacheBase::SetPolicyInternal(
@@ skipping 25 matching lines @@
   public_key_version_.valid = temp_public_key_version.valid;
 
   const bool new_policy_differs =
       !mandatory_policy_.Equals(mandatory_policy) ||
       !recommended_policy_.Equals(recommended_policy);
   mandatory_policy_.Swap(&mandatory_policy);
   recommended_policy_.Swap(&recommended_policy);
   initialization_complete_ = true;
 
   if (new_policy_differs || initialization_was_not_complete) {
-    FOR_EACH_OBSERVER(ConfigurationPolicyProvider::Observer,
-                      observer_list_, OnUpdatePolicy());
+    FOR_EACH_OBSERVER(Observer, observer_list_, OnCacheUpdate(this));
   }
   InformNotifier(CloudPolicySubsystem::SUCCESS,
                  CloudPolicySubsystem::NO_DETAILS);
   return true;
 }
 
 void CloudPolicyCacheBase::SetUnmanagedInternal(const base::Time& timestamp) {
   is_unmanaged_ = true;
   initialization_complete_ = true;
   public_key_version_.valid = false;
   mandatory_policy_.Clear();
   recommended_policy_.Clear();
   last_policy_refresh_time_ = timestamp;
 
-  FOR_EACH_OBSERVER(ConfigurationPolicyProvider::Observer,
-                    observer_list_, OnUpdatePolicy());
-}
-
-ConfigurationPolicyProvider* CloudPolicyCacheBase::GetManagedPolicyProvider() {
-  DCHECK(CalledOnValidThread());
-  return managed_policy_provider_.get();
-}
-
-ConfigurationPolicyProvider*
-    CloudPolicyCacheBase::GetRecommendedPolicyProvider() {
-  DCHECK(CalledOnValidThread());
-  return recommended_policy_provider_.get();
+  FOR_EACH_OBSERVER(Observer, observer_list_, OnCacheUpdate(this));
 }
 
 bool CloudPolicyCacheBase::DecodePolicyResponse(
     const em::PolicyFetchResponse& policy_response,
     PolicyMap* mandatory,
     PolicyMap* recommended,
     base::Time* timestamp,
     PublicKeyVersion* public_key_version) {
   std::string data = policy_response.policy_data();
   em::PolicyData policy_data;
@@ skipping 17 matching lines @@
 void CloudPolicyCacheBase::InformNotifier(
     CloudPolicySubsystem::PolicySubsystemState state,
     CloudPolicySubsystem::ErrorDetails error_details) {
   // TODO(jkummerow): To obsolete this NULL-check, make all uses of
   // UserPolicyCache explicitly set a notifier using |set_policy_notifier()|.
   if (notifier_)
     notifier_->Inform(state, error_details, PolicyNotifier::POLICY_CACHE);
 }
 
 }  // namespace policy