Display policy parsing errors in 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/logging.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
+#include "chrome/browser/policy/configuration_policy_handler.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
+#include "chrome/browser/policy/policy_error_map.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "policy/policy_constants.h"
 
 namespace policy {
 
 // This class functions as a container for policy status information used by the
 // ConfigurationPolicyReader class. It obtains policy values from a
 // ConfigurationPolicyProvider and maps them to their status information.
 class ConfigurationPolicyStatusKeeper {
  public:
@@ skipping 36 matching lines @@
 
 DictionaryValue* ConfigurationPolicyStatusKeeper::GetPolicyStatus(
     ConfigurationPolicyType policy) const {
   PolicyStatusMap::const_iterator entry = policy_map_.find(policy);
   return entry != policy_map_.end() ?
       (entry->second)->GetDictionaryValue() : NULL;
 }
 
 void ConfigurationPolicyStatusKeeper::GetPoliciesFromProvider(
     ConfigurationPolicyProvider* provider) {
-  scoped_ptr<PolicyMap> policies(new PolicyMap());
-  if (!provider->Provide(policies.get()))
-    LOG(WARNING) << "Failed to get policy from provider.";
+  PolicyMap policies;
+  if (!provider->Provide(&policies))
+    DLOG(WARNING) << "Failed to get policy from provider.";
 
-  PolicyMap::const_iterator policy = policies->begin();
-  for ( ; policy != policies->end(); ++policy) {
+  const ConfigurationPolicyHandler::HandlerList* handlers =
+      g_browser_process->browser_policy_connector()->
+          GetConfigurationPolicyHandlerList();
+
+  PolicyErrorMap errors;
+  ConfigurationPolicyHandler::HandlerList::const_iterator handler;
+  for (handler = handlers->begin(); handler != handlers->end(); ++handler) {

[Mattias Nissler (ping if slow), 2011/10/28 15:18:51]

no curlies necessary, and I can see one instance of no curlies in this file, so
consistency tells me to remove them.

[Joao da Silva, 2011/10/28 15:45:00]

Done.

+    (*handler)->CheckPolicySettings(&policies, &errors);
+  }
+
+  PolicyMap::const_iterator policy = policies.begin();
+  for ( ; policy != policies.end(); ++policy) {
     string16 name = ASCIIToUTF16(GetPolicyName(policy->first));
-
-    // TODO(simo) actually determine whether the policy is a user or a device
-    // one and whether the policy could be enforced or not once this information
-    // is available.
+    string16 error_message = errors.GetErrors(policy->first);
+    PolicyStatusInfo::PolicyStatus status =
+        error_message.empty() ? PolicyStatusInfo::ENFORCED
+                              : PolicyStatusInfo::FAILED;
+    // TODO(joaodasilva): determine whether this is a user or device policy.
     PolicyStatusInfo* info = new PolicyStatusInfo(name,
                                                   PolicyStatusInfo::USER,
                                                   policy_level_,
                                                   policy->second->DeepCopy(),
-                                                  PolicyStatusInfo::ENFORCED,
-                                                  string16());
+                                                  status,
+                                                  error_message);
     policy_map_[policy->first] = info;
   }
 }
 
 // ConfigurationPolicyReader
 ConfigurationPolicyReader::ConfigurationPolicyReader(
     ConfigurationPolicyProvider* provider,
     PolicyStatusInfo::PolicyLevel policy_level)
     : provider_(provider),
       policy_level_(policy_level) {
@@ skipping 107 matching lines @@
 
 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;
+  std::vector<DictionaryValue*> unset_policies;
 
   *any_policies_set = false;
   const PolicyDefinitionList* supported_policies =
       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());
+      unset_policies.push_back(info.GetDictionaryValue());
     } else {
       *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)
+  std::vector<DictionaryValue*>::const_iterator info = unset_policies.begin();
+  for ( ; info != unset_policies.end(); ++info)
     result->Append(*info);
 
   return result;
 }
 
 bool PolicyStatus::AddPolicyFromReaders(
     ConfigurationPolicyType policy, ListValue* list) const {
   DictionaryValue* mp_policy =
       managed_platform_->GetPolicyStatus(policy);
   DictionaryValue* mc_policy =
@@ skipping 11 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