Cleanup the policy code after the recent moves into the component.

components/policy/core/common/policy_service_impl.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 "components/policy/core/common/policy_service_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
+#include "base/values.h"
 #include "components/policy/core/common/policy_bundle.h"
 #include "components/policy/core/common/policy_map.h"
+#include "policy/policy_constants.h"
 
 namespace policy {
 
 typedef PolicyServiceImpl::Providers::const_iterator Iterator;
 
-PolicyServiceImpl::PolicyServiceImpl(
-    const Providers& providers,
-    const PreprocessCallback& preprocess_callback)
-    : preprocess_callback_(preprocess_callback),
-      update_task_ptr_factory_(this) {
+namespace {
+
+const char* kProxyPolicies[] = {
+  key::kProxyMode,
+  key::kProxyServerMode,
+  key::kProxyServer,
+  key::kProxyPacUrl,
+  key::kProxyBypassList,
+};
+
+void 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.
+
+  // The highest (level, scope) pair for an existing proxy policy is determined
+  // first, and then only policies with those exact attributes are merged.
+  PolicyMap::Entry current_priority;  // Defaults to the lowest priority.
+  scoped_ptr<base::DictionaryValue> proxy_settings(new base::DictionaryValue);
+  for (size_t i = 0; i < arraysize(kProxyPolicies); ++i) {
+    const PolicyMap::Entry* entry = policies->Get(kProxyPolicies[i]);
+    if (entry) {
+      if (entry->has_higher_priority_than(current_priority)) {
+        proxy_settings->Clear();
+        current_priority = *entry;
+      }
+      if (!entry->has_higher_priority_than(current_priority) &&
+          !current_priority.has_higher_priority_than(*entry)) {
+        proxy_settings->Set(kProxyPolicies[i], entry->value->DeepCopy());
+      }
+      policies->Erase(kProxyPolicies[i]);
+    }
+  }
+  // Sets the new |proxy_settings| if kProxySettings isn't set yet, or if the
+  // new priority is higher.
+  const PolicyMap::Entry* existing = policies->Get(key::kProxySettings);
+  if (!proxy_settings->empty() &&
+      (!existing || current_priority.has_higher_priority_than(*existing))) {
+    policies->Set(key::kProxySettings,
+                  current_priority.level,
+                  current_priority.scope,
+                  proxy_settings.release(),
+                  NULL);
+  }
+}
+
+}  // namespace
+
+PolicyServiceImpl::PolicyServiceImpl(const Providers& providers)
+    : update_task_ptr_factory_(this) {
   for (int domain = 0; domain < POLICY_DOMAIN_SIZE; ++domain)
     initialization_complete_[domain] = true;
   providers_ = providers;
   for (Iterator it = providers.begin(); it != providers.end(); ++it) {
     ConfigurationPolicyProvider* provider = *it;
     provider->AddObserver(this);
     for (int domain = 0; domain < POLICY_DOMAIN_SIZE; ++domain) {
       initialization_complete_[domain] &=
           provider->IsInitializationComplete(static_cast<PolicyDomain>(domain));
     }
@@ skipping 89 matching lines @@
   ObserverMap::iterator iterator = observers_.find(ns.domain);
   if (iterator != observers_.end()) {
     FOR_EACH_OBSERVER(PolicyService::Observer,
                       *iterator->second,
                       OnPolicyUpdated(ns, previous, current));
   }
 }
 
 void PolicyServiceImpl::MergeAndTriggerUpdates() {
   // Merge from each provider in their order of priority.
+  const PolicyNamespace chrome_namespace(POLICY_DOMAIN_CHROME, std::string());
   PolicyBundle bundle;
   for (Iterator it = providers_.begin(); it != providers_.end(); ++it) {
     PolicyBundle provided_bundle;
     provided_bundle.CopyFrom((*it)->policies());
-    if (!preprocess_callback_.is_null())
-      preprocess_callback_.Run(&provided_bundle);
+    FixDeprecatedPolicies(&provided_bundle.Get(chrome_namespace));
     bundle.MergeFrom(provided_bundle);
   }
 
   // Swap first, so that observers that call GetPolicies() see the current
   // values.
   policy_bundle_.Swap(&bundle);
 
   // Only notify observers of namespaces that have been modified.
   const PolicyMap kEmpty;
   PolicyBundle::const_iterator it_new = policy_bundle_.begin();
@@ skipping 64 matching lines @@
   if (refresh_pending_.empty() && !refresh_callbacks_.empty()) {
     std::vector<base::Closure> callbacks;
     callbacks.swap(refresh_callbacks_);
     std::vector<base::Closure>::iterator it;
     for (it = callbacks.begin(); it != callbacks.end(); ++it)
       it->Run();
   }
 }
 
 }  // namespace policy