Policy providers all get a SchemaRegistry to work with.

chrome/browser/policy/configuration_policy_provider.cc

 // Copyright (c) 2012 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/configuration_policy_provider.h"
 
 #include "base/callback.h"
 #include "chrome/browser/policy/external_data_fetcher.h"
-#include "chrome/browser/policy/policy_domain_descriptor.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "policy/policy_constants.h"
 
 namespace policy {
 
 namespace {
 
 const char* kProxyPolicies[] = {
   key::kProxyMode,
   key::kProxyServerMode,
@@ skipping 41 matching lines @@
                   proxy_settings.release(),
                   NULL);
   }
 }
 
 }  // namespace
 
 ConfigurationPolicyProvider::Observer::~Observer() {}
 
 ConfigurationPolicyProvider::ConfigurationPolicyProvider()
-    : did_shutdown_(false) {}
+    : did_shutdown_(false),
+      schema_registry_(NULL) {}
 
 ConfigurationPolicyProvider::~ConfigurationPolicyProvider() {
   DCHECK(did_shutdown_);
 }
 
-void ConfigurationPolicyProvider::Init() {}
+void ConfigurationPolicyProvider::Init(SchemaRegistry* registry) {
+  schema_registry_ = registry;
+  schema_registry_->AddObserver(this);
+}
 
 void ConfigurationPolicyProvider::Shutdown() {
   did_shutdown_ = true;
+  if (schema_registry_) {
+    // Unit tests don't initialize the browser_policy_connector but call

[bartfab (slow), 2013/11/05 15:53:04]

Written with underscores like this, browser_policy_connector clearly refers to
symbol. But there is insufficient context to figure out what symbol is meant
exactly. Is this a member named browser_policy_connector? Or a getter? Which
class does that member/symbol belong to? I think it would be better to refer to
the human-readable concept here ("browser policy connector," without
underscores) rather than a specific symbol name.

[Joao da Silva, 2013/11/07 13:15:00]

Done.

+    // shutdown; handle that.
+    schema_registry_->RemoveObserver(this);
+    schema_registry_ = NULL;
+  }
 }
 
 bool ConfigurationPolicyProvider::IsInitializationComplete(
     PolicyDomain domain) const {
   return true;
 }
 
+void ConfigurationPolicyProvider::OnSchemaRegistryUpdated(
+    const scoped_refptr<SchemaMap>& current_map,

[bartfab (slow), 2013/11/05 15:53:04]

General question: Does anyone ever use the current_map argument of
OnSchemaRegistryUpdated? If it is generally discarded, would it make sense to
remove this argument and have everyone call schema_map() if needed?

[Joao da Silva, 2013/11/07 13:15:00]

That's right, removed.

+    bool has_new_schemas) {
+  if (has_new_schemas)
+    RefreshPolicies();
+}
+
 void ConfigurationPolicyProvider::UpdatePolicy(
     scoped_ptr<PolicyBundle> bundle) {
   if (bundle.get())
     policy_bundle_.Swap(bundle.get());
   else
     policy_bundle_.Clear();
   FixDeprecatedPolicies(&policy_bundle_.Get(
       PolicyNamespace(POLICY_DOMAIN_CHROME, std::string())));
   FOR_EACH_OBSERVER(ConfigurationPolicyProvider::Observer,
                     observer_list_,
                     OnUpdatePolicy(this));
 }
 
+const scoped_refptr<SchemaMap>&
+ConfigurationPolicyProvider::schema_map() const {
+  return schema_registry_->schema_map();
+}
+
 void ConfigurationPolicyProvider::AddObserver(Observer* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void ConfigurationPolicyProvider::RemoveObserver(Observer* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
-void ConfigurationPolicyProvider::RegisterPolicyDomain(
-    scoped_refptr<const PolicyDomainDescriptor> descriptor) {}
-
 }  // namespace policy