Removed ConfigurationPolicyType and extended PolicyMap.

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 <algorithm>
+
 #include "chrome/browser/policy/policy_map.h"
 #include "policy/policy_constants.h"
 
 namespace policy {
 
 namespace {
 
-ConfigurationPolicyType kProxyPolicies[] = {
-  kPolicyProxyMode,
-  kPolicyProxyServerMode,
-  kPolicyProxyServer,
-  kPolicyProxyPacUrl,
-  kPolicyProxyBypassList,
+const char* kProxyPolicies[] = {
+  key::kProxyMode,
+  key::kProxyServerMode,
+  key::kProxyServer,
+  key::kProxyPacUrl,
+  key::kProxyBypassList,
 };
 
 }  // namespace
 
 ConfigurationPolicyProvider::Observer::~Observer() {}
 
 void ConfigurationPolicyProvider::Observer::OnProviderGoingAway(
     ConfigurationPolicyProvider* provider) {}
 
 // Class ConfigurationPolicyProvider.
@@ skipping 45 matching lines @@
 }
 
 // static
 void ConfigurationPolicyProvider::FixDeprecatedPolicies(PolicyMap* policies) {
   // Proxy settings have been configured by 5 policies that didn't mix well
   // together, and maps of policies had to take this into account when merging
   // policy sources. The proxy settings will eventually be configured by a
   // single Dictionary policy when all providers have support for that. For
   // now, the individual policies are mapped here to a single Dictionary policy
   // that the rest of the policy machinery uses.
+  PolicyLevel level = POLICY_LEVEL_RECOMMENDED;
+  PolicyScope scope = POLICY_SCOPE_USER;
   scoped_ptr<DictionaryValue> proxy_settings(new DictionaryValue);
   for (size_t i = 0; i < arraysize(kProxyPolicies); ++i) {
-    const Value* value = policies->Get(kProxyPolicies[i]);
-    if (value) {
-      proxy_settings->Set(GetPolicyName(kProxyPolicies[i]), value->DeepCopy());
+    const PolicyMap::Entry* entry = policies->Get(kProxyPolicies[i]);
+    if (entry) {
+      // The level and scope of the merged policy is the highest of any of the
+      // individual deprecated policies.

[Mattias Nissler (ping if slow), 2012/01/18 15:07:07]

I think this is actually incorrect. Assume you have proxy config set bot
recommended and mandatory. If mandatory specifies PAC but recommended specifies
fixed server, you'll combine them here. You should rather figure out the
highest-priority level/scope pair you have and only consider settings that have
that exact level/scope pair configured.

[Joao da Silva, 2012/01/18 16:49:29]

Thanks for catching this, that is exactly what should be done here. Fixed and
added a test for this in configuration_policy_pref_store_unittest.cc.

+      level = std::max(level, entry->level);
+      scope = std::max(scope, entry->scope);
+      proxy_settings->Set(kProxyPolicies[i], entry->value->DeepCopy());
       policies->Erase(kProxyPolicies[i]);
     }
   }
-  if (!proxy_settings->empty() && !policies->Get(kPolicyProxySettings))
-    policies->Set(kPolicyProxySettings, proxy_settings.release());
+  if (!proxy_settings->empty() && !policies->Get(key::kProxySettings))
+    policies->Set(key::kProxySettings, level, scope, proxy_settings.release());
 }
 
 void ConfigurationPolicyProvider::AddObserver(Observer* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void ConfigurationPolicyProvider::RemoveObserver(Observer* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
@@ skipping 22 matching lines @@
 
 void ConfigurationPolicyObserverRegistrar::OnProviderGoingAway(
     ConfigurationPolicyProvider* provider) {
   DCHECK_EQ(provider_, provider);
   observer_->OnProviderGoingAway(provider_);
   provider_->RemoveObserver(this);
   provider_ = NULL;
 }
 
 }  // namespace policy