Refactored the CloudPolicyProvider so that it becomes initialized once and stays initialized.

chrome/browser/policy/cloud_policy_provider.h

 // 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.
 
 #ifndef CHROME_BROWSER_POLICY_CLOUD_POLICY_PROVIDER_H_
 #define CHROME_BROWSER_POLICY_CLOUD_POLICY_PROVIDER_H_
 #pragma once
 
+#include <set>
+
 #include "base/basictypes.h"
+#include "chrome/browser/policy/cloud_policy_cache_base.h"
 #include "chrome/browser/policy/configuration_policy_provider.h"
+#include "chrome/browser/policy/policy_map.h"
 
 namespace policy {
 
-class CloudPolicyCacheBase;
+class BrowserPolicyConnector;
 
-// A policy provider having multiple backend caches, combining their relevant
-// PolicyMaps and keeping the result cached. The underlying caches are kept as
-// weak references and can be added  dynamically. Also the
-// |CloudPolicyProvider| instance listens to cache-notifications and removes
-// the caches automatically when they go away. The order in which the caches are
-// stored matters! The first cache is applied as is and the following caches
-// only contribute the not-yet applied policies. There are two functions to add
-// a new cache:
-//   PrependCache(cache): adds |cache| to the front (i.e. most important cache).
-//   AppendCache(cache):  adds |cache| to the back (i.e. least important cache).
-class CloudPolicyProvider : public ConfigurationPolicyProvider {
+// A policy provider that merges the policies contained in the caches it
+// observes. The caches receive their policies by fetching them from the cloud,
+// through the CloudPolicyController.
+class CloudPolicyProvider : public ConfigurationPolicyProvider,
+                            public CloudPolicyCacheBase::Observer {
  public:
-  explicit CloudPolicyProvider(const PolicyDefinitionList* policy_list);
+  CloudPolicyProvider(BrowserPolicyConnector* browser_policy_connector,
+                      const PolicyDefinitionList* policy_list,
+                      PolicyLevel level);
   virtual ~CloudPolicyProvider();
 
-  // Adds a new instance of CloudPolicyCacheBase to the end of |caches_|.
-  // Does not take ownership of |cache| and listens to OnCacheGoingAway to
-  // automatically remove it from |caches_|.
-  virtual void AppendCache(CloudPolicyCacheBase* cache) = 0;
+  // Sets the user policy cache. This must be invoked only once, and |cache|
+  // must not be NULL.
+  void SetUserPolicyCache(CloudPolicyCacheBase* cache);
 
-  // Adds a new instance of CloudPolicyCacheBase to the beginning of |caches_|.
-  // Does not take ownership of |cache| and listens to OnCacheGoingAway to
-  // automatically remove it from |caches_|.
-  virtual void PrependCache(CloudPolicyCacheBase* cache) = 0;
+#if defined(OS_CHROMEOS)
+  // Sets the device policy cache. This must be invoked only once, and |cache|
+  // must not be NULL.
+  void SetDevicePolicyCache(CloudPolicyCacheBase* cache);
+#endif
+
+  // ConfigurationPolicyProvider implementation.
+  virtual bool ProvideInternal(PolicyMap* result) OVERRIDE;
+  virtual bool IsInitializationComplete() const OVERRIDE;
+  virtual void RefreshPolicies() OVERRIDE;
+
+  // CloudPolicyCacheBase::Observer implementation.
+  virtual void OnCacheUpdate(CloudPolicyCacheBase* cache) OVERRIDE;
+  virtual void OnCacheGoingAway(CloudPolicyCacheBase* cache) OVERRIDE;
 
  private:
+  // Indices of the known caches in |caches_|.
+  enum {
+    CACHE_USER,
+#if defined(OS_CHROMEOS)
+    CACHE_DEVICE,
+#endif
+    CACHE_SIZE,
+  };
+
+  // Merges policies from both caches, and triggers a notification if ready.
+  void Merge();
+
+  // The device and user policy caches, whose policies are provided by |this|.
+  // Both are initially NULL, and the provider only becomes initialized once
+  // all the caches are available and ready.
+  CloudPolicyCacheBase* caches_[CACHE_SIZE];
+
+  // Weak pointer to the connector. Guaranteed to outlive |this|.
+  BrowserPolicyConnector* browser_policy_connector_;
+
+  // The policy level published by this provider.
+  PolicyLevel level_;
+
+  // Whether all caches are present and fully initialized.
+  bool initialization_complete_;
+
+  // Used to determine when updates due to a RefreshPolicies() call have been
+  // completed.
+  std::set<const CloudPolicyCacheBase*> pending_updates_;
+
+  // The currently valid combination of the caches. ProvideInternal() fills
+  // |results| with a copy of |combined_|.
+  PolicyMap combined_;
+
   DISALLOW_COPY_AND_ASSIGN(CloudPolicyProvider);
 };
 
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_POLICY_CLOUD_POLICY_PROVIDER_H_