[Policy Experimental] Add "recommended" policies for URL exceptions.

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"
@@ skipping 38 matching lines @@
 bool PolicyMap::Entry::Equals(const PolicyMap::Entry& other) const {
   return level == other.level &&
          scope == other.scope &&
          source == other.source &&  // Necessary for PolicyUIHandler observers.
                                     // They have to update when sources change.
          base::Value::Equals(value, other.value) &&
          ExternalDataFetcher::Equals(external_data_fetcher,
                                      other.external_data_fetcher);
 }
 
+PolicyMap::PolicyMapKey::PolicyMapKey() {
+}
+
+PolicyMap::PolicyMapKey::PolicyMapKey(const std::string& name_in)
+    : name(name_in) {
+}
+
+PolicyMap::PolicyMapKey::PolicyMapKey(const std::string& name_in,
+                                      PolicyLevel level_in)
+    : name(name_in), level(level_in) {
+}
+
+bool PolicyMap::PolicyMapKey::operator==(const PolicyMapKey& other) const {
+  return name == other.name && level == other.level;
+}
+
+bool PolicyMap::PolicyMapKey::operator<(const PolicyMapKey& other) const {
+  int name_comp = name.compare(other.name);
+  if (name_comp)
+    return name_comp < 0;
+  // Compare policy level. Should be consistent with has_higher_priority_than().
+  return level > other.level;
+}
+
+int PolicyMap::PolicyMapKey::compare(const PolicyMapKey& other) const {
+  int name_comp = name.compare(other.name);
+  if (name_comp)
+    return name_comp;
+  return level > other.level ? -1 : (level < other.level ? 1 : 0);
+}
+
 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_iterator entry = lower_bound(policy);
+  return entry == map_.end() || entry->first.name != policy ?
+      nullptr : &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;
+  const_iterator entry = lower_bound(policy);
+  return entry == map_.end() || entry->first.name != policy ?
+      nullptr : entry->second.value;
 }
 
 void PolicyMap::Set(const std::string& policy,
                     PolicyLevel level,
                     PolicyScope scope,
                     PolicySource source,
                     base::Value* value,
                     ExternalDataFetcher* external_data_fetcher) {
-  Entry& entry = map_[policy];
+  Entry& entry = map_[PolicyMapKey(policy, level)];
   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()) {
+  PolicyMapType::iterator it = lower_bound(policy);
+  PolicyMapType::iterator end_it = map_.end();
+  while (it != map_.end() && it->first.name == policy) {
+    PolicyMapType::iterator next_it = it;
+    ++next_it;
     it->second.DeleteOwnedMembers();
     map_.erase(it);
+    it = next_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.source,
+    Set(it->first.name, it->first.level, entry.scope, entry.source,
         entry.value->DeepCopy(),
         entry.external_data_fetcher
             ? new ExternalDataFetcher(*entry.external_data_fetcher)
             : nullptr);
   }
 }
 
 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.source,
+    const_iterator this_it = map_.find(it->first);
+    if (this_it == map_.end() ||
+        it->second.has_higher_priority_than(this_it->second)) {
+      Set(it->first.name, it->first.level, it->second.scope, it->second.source,
           it->second.value->DeepCopy(),
           it->second.external_data_fetcher
-              ? new ExternalDataFetcher(
-                    *it->second.external_data_fetcher)
+              ? new ExternalDataFetcher(*it->second.external_data_fetcher)
               : nullptr);
     }
   }
 }
 
 void PolicyMap::LoadFrom(
     const base::DictionaryValue* policies,
     PolicyLevel level,
     PolicyScope scope,
     PolicySource source) {
   for (base::DictionaryValue::Iterator it(*policies);
        !it.IsAtEnd(); it.Advance()) {
     Set(it.key(), level, scope, source, it.value().DeepCopy(), nullptr);
   }
 }
 
 void PolicyMap::GetDifferingKeys(const PolicyMap& other,
-                                 std::set<std::string>* differing_keys) const {
+    std::set<PolicyMap::PolicyMapKey>* differing_keys) const {
   // Walk over the maps in lockstep, adding everything that is different.
   const_iterator iter_this(begin());
   const_iterator iter_other(other.begin());
   while (iter_this != end() && iter_other != other.end()) {
     const int diff = iter_this->first.compare(iter_other->first);
     if (diff == 0) {
       if (!iter_this->second.Equals(iter_other->second))
         differing_keys->insert(iter_this->first);
       ++iter_this;
       ++iter_other;
     } else if (diff < 0) {
       differing_keys->insert(iter_this->first);
       ++iter_this;
     } else {
       differing_keys->insert(iter_other->first);
       ++iter_other;
     }
   }
 
   // Add the remaining entries.
   for ( ; iter_this != end(); ++iter_this)
       differing_keys->insert(iter_this->first);
   for ( ; iter_other != other.end(); ++iter_other)
       differing_keys->insert(iter_other->first);
 }
 
+void PolicyMap::GetDifferingKeyNames(const PolicyMap& other,
+    std::set<std::string>* differing_key_names) const {
+  std::set<PolicyMap::PolicyMapKey> differing_keys;
+  GetDifferingKeys(other, &differing_keys);
+  for (const auto& key : differing_keys) {
+    differing_key_names->insert(key.name);
+  }
+}
+
 void PolicyMap::FilterLevel(PolicyLevel level) {
   PolicyMapType::iterator iter(map_.begin());
   while (iter != map_.end()) {
-    if (iter->second.level != level) {
+    if (iter->first.level != level) {
       iter->second.DeleteOwnedMembers();
       map_.erase(iter++);
     } else {
       ++iter;
     }
   }
 }
 
 bool PolicyMap::Equals(const PolicyMap& other) const {
   return other.size() == size() &&
       std::equal(begin(), end(), other.begin(), MapEntryEquals);
 }
 
 bool PolicyMap::empty() const {
   return map_.empty();
 }
 
 size_t PolicyMap::size() const {
   return map_.size();
 }
 
 PolicyMap::const_iterator PolicyMap::begin() const {
   return map_.begin();
 }
 
 PolicyMap::const_iterator PolicyMap::end() const {
   return map_.end();
 }
 
+void PolicyMap::next_dominant(PolicyMap::const_iterator* it) const {
+  DCHECK((*it) != map_.end());
+  const std::string& prev_name = (*it)->first.name;
+  do {
+    ++(*it);
+  } while ((*it) != map_.end() && (*it)->first.name == prev_name);
+}
+
+void PolicyMap::next_all(PolicyMap::const_iterator* it) const {
+  DCHECK((*it) != map_.end());
+  ++(*it);
+}
+
 void PolicyMap::Clear() {
   for (PolicyMapType::iterator it = map_.begin(); it != map_.end(); ++it)
     it->second.DeleteOwnedMembers();
   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);
 }
 
+PolicyMap::PolicyMapType::iterator PolicyMap::lower_bound(
+      const std::string& policy) {
+  PolicyMapKey key(policy);
+  return map_.lower_bound(key);
+}
+
+PolicyMap::const_iterator PolicyMap::lower_bound(
+      const std::string& policy) const {
+  PolicyMapKey key(policy);
+  return map_.lower_bound(key);
+}
+
 }  // namespace policy