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

components/policy/core/common/policy_map.cc

 // Copyright 2013 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_map.h"
 
 #include <algorithm>
 
 #include "base/callback.h"
 #include "base/stl_util.h"
 
 namespace policy {
 
 PolicyMap::Entry::Entry()
     : level(POLICY_LEVEL_RECOMMENDED),
       scope(POLICY_SCOPE_USER),
       value(NULL),
-      external_data_fetcher(NULL) {}
+      external_data_fetcher(NULL),
+      source(POLICY_SOURCE_UNKNOWN) {}
 
 void PolicyMap::Entry::DeleteOwnedMembers() {
   delete value;
   value = NULL;
   delete external_data_fetcher;
   external_data_fetcher = NULL;
 }
 
 scoped_ptr<PolicyMap::Entry> PolicyMap::Entry::DeepCopy() const {
   scoped_ptr<Entry> copy(new Entry);
   copy->level = level;
   copy->scope = scope;
+  copy->source = source;
   if (value)
     copy->value = value->DeepCopy();
   if (external_data_fetcher) {
     copy->external_data_fetcher =
         new ExternalDataFetcher(*external_data_fetcher);
   }
   return copy.Pass();
 }
 
 bool PolicyMap::Entry::has_higher_priority_than(
     const PolicyMap::Entry& other) const {
   if (level == other.level)
     return scope > other.scope;
   else
     return level > other.level;
 }
 
 bool PolicyMap::Entry::Equals(const PolicyMap::Entry& other) const {
   return level == other.level &&
          scope == other.scope &&
+         source == other.source &&  // Necessary for PolicyUIHandler observers.

[bartfab (slow), 2015/09/14 14:42:27]

You can leave the comment here if you want but in general, I see no real need
for it. Equals() should obviously only return |true| if the two objects really
are... equal.

[fhorschig, 2015/09/16 13:52:05]

This value is far less important for the Equality. It is tempting to remove it
because "hey, it doesn't matter where the same configuration comes from!'. So
this comment is just to prevent this thought.

+                                    // They have to update when sources change.
          base::Value::Equals(value, other.value) &&
          ExternalDataFetcher::Equals(external_data_fetcher,
                                      other.external_data_fetcher);
 }
 
 PolicyMap::PolicyMap() {
 }
 
 PolicyMap::~PolicyMap() {
   Clear();
 }
 
 const PolicyMap::Entry* PolicyMap::Get(const std::string& policy) const {
   PolicyMapType::const_iterator entry = map_.find(policy);
   return entry == map_.end() ? NULL : &entry->second;
 }
 
 const base::Value* PolicyMap::GetValue(const std::string& policy) const {
   PolicyMapType::const_iterator entry = map_.find(policy);
   return entry == map_.end() ? NULL : entry->second.value;
 }
 
+void PolicyMap::ApplySourceToEntries(PolicySource source) {
+  for (auto& map_entry : map_) {
+    if (map_entry.second.source == POLICY_SOURCE_UNKNOWN)
+      map_entry.second.source = source;
+  }
+}
+
 void PolicyMap::Set(const std::string& policy,
                     PolicyLevel level,
                     PolicyScope scope,
                     base::Value* value,
                     ExternalDataFetcher* external_data_fetcher) {
+  SetWithSource(policy, level, scope, value, external_data_fetcher,
+      POLICY_SOURCE_UNKNOWN);
+}
+
+void PolicyMap::SetWithSource(const std::string& policy,
+                    PolicyLevel level,
+                    PolicyScope scope,
+                    base::Value* value,
+                    ExternalDataFetcher* external_data_fetcher,
+                    PolicySource source) {
   Entry& entry = map_[policy];
   entry.DeleteOwnedMembers();
   entry.level = level;
   entry.scope = scope;
+  entry.source = source;
   entry.value = value;
   entry.external_data_fetcher = external_data_fetcher;
 }
 
 void PolicyMap::Erase(const std::string& policy) {
   PolicyMapType::iterator it = map_.find(policy);
   if (it != map_.end()) {
     it->second.DeleteOwnedMembers();
     map_.erase(it);
   }
 }
 
 void PolicyMap::Swap(PolicyMap* other) {
   map_.swap(other->map_);
 }
 
 void PolicyMap::CopyFrom(const PolicyMap& other) {
   Clear();
   for (const_iterator it = other.begin(); it != other.end(); ++it) {
     const Entry& entry = it->second;
-    Set(it->first, entry.level, entry.scope,
-        entry.value->DeepCopy(), entry.external_data_fetcher ?
-            new ExternalDataFetcher(*entry.external_data_fetcher) : NULL);
+    SetWithSource(it->first, entry.level, entry.scope, entry.value->DeepCopy(),
+                  entry.external_data_fetcher
+                      ? new ExternalDataFetcher(*entry.external_data_fetcher)
+                      : NULL,

[bartfab (slow), 2015/09/14 14:42:27]

Nit: s/NULL/nullptr/

[fhorschig, 2015/09/16 13:52:05]

Done.

+                  entry.source);
   }
 }
 
 scoped_ptr<PolicyMap> PolicyMap::DeepCopy() const {
   PolicyMap* copy = new PolicyMap();
   copy->CopyFrom(*this);
   return make_scoped_ptr(copy);
 }
 
 void PolicyMap::MergeFrom(const PolicyMap& other) {
   for (const_iterator it = other.begin(); it != other.end(); ++it) {
     const Entry* entry = Get(it->first);
     if (!entry || it->second.has_higher_priority_than(*entry)) {
-      Set(it->first, it->second.level, it->second.scope,
-          it->second.value->DeepCopy(), it->second.external_data_fetcher ?
-              new ExternalDataFetcher(*it->second.external_data_fetcher) :
-              NULL);
+      SetWithSource(it->first, it->second.level, it->second.scope,
+                    it->second.value->DeepCopy(),
+                    it->second.external_data_fetcher
+                        ? new ExternalDataFetcher(
+                              *it->second.external_data_fetcher)
+                        : NULL,

[bartfab (slow), 2015/09/14 14:42:27]

Nit: s/NULL/nullptr/

[fhorschig, 2015/09/16 13:52:05]

Done.

+                    it->second.source);
     }
   }
 }
 
 void PolicyMap::LoadFrom(
     const base::DictionaryValue* policies,
     PolicyLevel level,
     PolicyScope scope) {
   for (base::DictionaryValue::Iterator it(*policies);
        !it.IsAtEnd(); it.Advance()) {
@@ skipping 68 matching lines @@
   map_.clear();
 }
 
 // static
 bool PolicyMap::MapEntryEquals(const PolicyMap::PolicyMapType::value_type& a,
                                const PolicyMap::PolicyMapType::value_type& b) {
   return a.first == b.first && a.second.Equals(b.second);
 }
 
 }  // namespace policy