Policy providers all get a SchemaRegistry to work with.

chrome/browser/policy/cloud/component_cloud_policy_store.cc

 // Copyright (c) 2013 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/component_cloud_policy_store.h"
 
 #include "base/callback.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/sha1.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/policy/cloud/cloud_policy_constants.h"
 #include "chrome/browser/policy/cloud/cloud_policy_validator.h"
-#include "chrome/browser/policy/cloud/resource_cache.h"
 #include "chrome/browser/policy/external_data_fetcher.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "chrome/browser/policy/proto/cloud/chrome_extension_policy.pb.h"
 #include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h"
 #include "url/gurl.h"
 
 namespace em = enterprise_management;
 
 namespace policy {
 
@@ skipping 155 matching lines @@
 
   cache_->Delete(constants->proto_cache_key, ns.component_id);
   cache_->Delete(constants->data_cache_key, ns.component_id);
 
   if (!policy_bundle_.Get(ns).empty()) {
     policy_bundle_.Get(ns).Clear();
     delegate_->OnComponentCloudPolicyStoreUpdated();
   }
 }
 
-void ComponentCloudPolicyStore::Purge(PolicyDomain domain,
-                                      const std::set<std::string>& keep) {
+void ComponentCloudPolicyStore::Purge(
+    PolicyDomain domain,
+    const ResourceCache::SubkeyFilter& filter) {
   DCHECK(CalledOnValidThread());
   const DomainConstants* constants = GetDomainConstants(domain);
   if (!constants)
     return;
 
-  cache_->PurgeOtherSubkeys(constants->proto_cache_key, keep);
-  cache_->PurgeOtherSubkeys(constants->data_cache_key, keep);
+  cache_->FilterSubkeys(constants->proto_cache_key, filter);
+  cache_->FilterSubkeys(constants->data_cache_key, filter);
 
   // Stop serving policies for purged namespaces.
   bool purged_current_policies = false;
   for (PolicyBundle::const_iterator it = policy_bundle_.begin();
        it != policy_bundle_.end(); ++it) {
     if (it->first.domain == domain &&
-        keep.find(it->first.component_id) == keep.end() &&
+        filter.Run(it->first.component_id) &&
         !policy_bundle_.Get(it->first).empty()) {
       policy_bundle_.Get(it->first).Clear();
       purged_current_policies = true;
     }
   }
 
   // Purge cached hashes, so that those namespaces can be fetched again if the
   // policy state changes.
   std::map<PolicyNamespace, std::string>::iterator it = cached_hashes_.begin();
   while (it != cached_hashes_.end()) {
-    if (it->first.domain == domain &&
-        keep.find(it->first.component_id) == keep.end()) {
+    if (it->first.domain == domain && filter.Run(it->first.component_id)) {
       std::map<PolicyNamespace, std::string>::iterator prev = it;
       ++it;
       cached_hashes_.erase(prev);
     } else {
       ++it;
     }
   }
 
   if (purged_current_policies)
     delegate_->OnComponentCloudPolicyStoreUpdated();
@@ skipping 107 matching lines @@
     // If policy for components is ever used for device-level settings then
     // this must support a configurable scope; assuming POLICY_SCOPE_USER is
     // fine for now.
     policy->Set(it.key(), level, POLICY_SCOPE_USER, value.release(), NULL);
   }
 
   return true;
 }
 
 }  // namespace policy