Add source column to chrome://policy showing the origins of policies.

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/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "components/policy/core/common/policy_bundle.h"
 #include "components/policy/core/common/policy_map.h"
+#include "components/policy/core/common/policy_types.h"
 #include "policy/policy_constants.h"
 
 namespace policy {
 
 typedef PolicyServiceImpl::Providers::const_iterator Iterator;
 
 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.
+  PolicySource inherited_source = POLICY_SOURCE_ENTERPRISE_DEFAULT;
   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->source > inherited_source)  // Higher priority?
+          inherited_source = entry->source;
       }
       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,
+                  inherited_source,
                   proxy_settings.release(),
                   NULL);
   }
 }
 
 }  // namespace
 
 PolicyServiceImpl::PolicyServiceImpl(const Providers& providers)
     : update_task_ptr_factory_(this) {
   for (int domain = 0; domain < POLICY_DOMAIN_SIZE; ++domain)
@@ skipping 196 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