Implemented status section functionality for about:policy.

chrome/browser/policy/configuration_policy_reader.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/configuration_policy_reader.h"
 
 #include <map>
 #include <vector>
 
 #include "base/stl_util.h"
@@ skipping 102 matching lines @@
 }
 
 void ConfigurationPolicyReader::OnUpdatePolicy() {
   Refresh();
 }
 
 void ConfigurationPolicyReader::OnProviderGoingAway() {
   provider_ = NULL;
 }
 
+void ConfigurationPolicyReader::AddObserver(Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
+void ConfigurationPolicyReader::RemoveObserver(Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 // static
 ConfigurationPolicyReader*
     ConfigurationPolicyReader::CreateManagedPlatformPolicyReader() {
   BrowserPolicyConnector* connector =
       g_browser_process->browser_policy_connector();
   return new ConfigurationPolicyReader(
     connector->GetManagedPlatformProvider(), PolicyStatusInfo::MANDATORY);
 }
 
 // static
@@ skipping 36 matching lines @@
 }
 
 void ConfigurationPolicyReader::Refresh() {
   if (!provider_)
     return;
 
   // Read policy state into a new keeper and swap out old keeper.
   scoped_ptr<ConfigurationPolicyStatusKeeper> new_keeper(
       new ConfigurationPolicyStatusKeeper(provider_, policy_level_));
   policy_keeper_.reset(new_keeper.release());
+
+  FOR_EACH_OBSERVER(Observer, observers_, OnPolicyValuesChanged());
 }
 
 // PolicyStatus
 PolicyStatus::PolicyStatus(ConfigurationPolicyReader* managed_platform,
                            ConfigurationPolicyReader* managed_cloud,
                            ConfigurationPolicyReader* recommended_platform,
                            ConfigurationPolicyReader* recommended_cloud)
     : managed_platform_(managed_platform),
       managed_cloud_(managed_cloud),
       recommended_platform_(recommended_platform),
       recommended_cloud_(recommended_cloud) {
 }
 
 PolicyStatus::~PolicyStatus() {
 }
 
-ListValue* PolicyStatus::GetPolicyStatusList(bool* any_policies_sent) const {
+void PolicyStatus::AddObserver(Observer* observer) const {
+  managed_platform_->AddObserver(observer);
+  managed_cloud_->AddObserver(observer);
+  recommended_platform_->AddObserver(observer);
+  recommended_cloud_->AddObserver(observer);
+}
+
+void PolicyStatus::RemoveObserver(Observer* observer) const {
+  managed_platform_->RemoveObserver(observer);
+  managed_cloud_->RemoveObserver(observer);
+  recommended_platform_->RemoveObserver(observer);
+  recommended_cloud_->RemoveObserver(observer);
+}
+
+ListValue* PolicyStatus::GetPolicyStatusList(bool* any_policies_set) const {
   ListValue* result = new ListValue();
   std::vector<DictionaryValue*> unsent_policies;
 
-  *any_policies_sent = false;
+  *any_policies_set = false;
   const PolicyDefinitionList* supported_policies =
       ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList();
   const PolicyDefinitionList::Entry* policy = supported_policies->begin;
   for ( ; policy != supported_policies->end; ++policy) {
     if (!AddPolicyFromReaders(policy->policy_type, result)) {
       PolicyStatusInfo info(ASCIIToUTF16(policy->name),
                             PolicyStatusInfo::SOURCE_TYPE_UNDEFINED,
                             PolicyStatusInfo::LEVEL_UNDEFINED,
                             Value::CreateNullValue(),
                             PolicyStatusInfo::STATUS_UNDEFINED,
                             string16());
       unsent_policies.push_back(info.GetDictionaryValue());
     } else {
-      *any_policies_sent = true;
+      *any_policies_set = true;
     }
   }
 
   // Add policies that weren't actually sent from providers to list.
   std::vector<DictionaryValue*>::const_iterator info = unsent_policies.begin();
   for ( ; info != unsent_policies.end(); ++info)
     result->Append(*info);
 
   return result;
 }
@@ skipping 43 matching lines @@
     list->Append(mc_policy);
   if (rp_policy)
     list->Append(rp_policy);
   if (rc_policy)
     list->Append(rc_policy);
 
   return added_policy;
 }
 
 } // namespace policy