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 observer updates.

[Thiemo Nagel, 2015/09/04 20:15:54]

It would be nice to mention which observer benefits from this.

[fhorschig, 2015/09/07 14:09:34]

Done.

          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::SetEntrySources(PolicySource source) {
+  for (PolicyMapType::iterator it = map_.begin(); it != map_.end(); ++it) {

[Thiemo Nagel, 2015/09/04 20:15:54]

Please use range loop.

[fhorschig, 2015/09/07 14:09:34]

Done.

+    if (source != POLICY_SOURCE_PLATFORM &&
+        (it->second.source == POLICY_SOURCE_ENTERPRISE_DEFAULT ||

[Thiemo Nagel, 2015/09/04 20:15:54]

I still don't get what's happening here.  It seems wrong to have such
specialized functionality to be part of the very generic PolicyMap class.

Would it be possible to just ignore all entries that have (it->second.source !=
POLICY_SOURCE_UNKNOWN)?

[fhorschig, 2015/09/07 14:09:34]

Currently, Yes. (If policies were set multiple time, this could be a problem,
but I can't find a place where this might occur, so I think the simpler way is
better.)

+         it->second.source == POLICY_SOURCE_ENFORCED))
+      continue;  // Enterprise and enforced policies can only be overridden by
+                 // platform-specific configurations (Like debug JSONs).
+    it->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,
+                  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,
+                    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