Update URLPatternSet to contain a std::set instead of std::vector.

chrome/common/extensions/extension_permission_set.cc

 // Copyright (c) 2011 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 "chrome/common/extensions/extension_permission_set.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/memory/singleton.h"
@@ skipping 63 matching lines @@
   "tabs.update",
 };
 const size_t kNumNonPermissionFunctionNames =
     arraysize(kNonPermissionFunctionNames);
 
 const char kOldUnlimitedStoragePermission[] = "unlimited_storage";
 const char kWindowsPermission[] = "windows";
 
 void AddPatternsAndRemovePaths(const URLPatternSet& set, URLPatternSet* out) {
   CHECK(out);
-  const URLPatternList& patterns = set.patterns();
-  for (size_t i = 0; i < patterns.size(); ++i) {
-    URLPattern p = patterns.at(i);
+  for (URLPatternSet::const_iterator i = set.begin(); i != set.end(); ++i) {
+    URLPattern p = *i;
     p.SetPath("/*");
     out->AddPattern(p);
   }
 }
 
 } // namespace
 
 //
 // PermissionMessage
 //
 
 // static
 ExtensionPermissionMessage ExtensionPermissionMessage::CreateFromHostList(
-    const std::vector<std::string>& hosts) {
-  CHECK(hosts.size() > 0);
+    const std::set<std::string>& hosts) {
+  std::vector<std::string> host_list(hosts.begin(), hosts.end());
+  CHECK(host_list.size() > 0);
   ID message_id;
   string16 message;
-  switch (hosts.size()) {
+
+  switch (host_list.size()) {
     case 1:
       message_id = kHosts1;
       message = l10n_util::GetStringFUTF16(IDS_EXTENSION_PROMPT_WARNING_1_HOST,
-                                           UTF8ToUTF16(hosts[0]));
+                                           UTF8ToUTF16(host_list[0]));
       break;
     case 2:
       message_id = kHosts2;
       message = l10n_util::GetStringFUTF16(IDS_EXTENSION_PROMPT_WARNING_2_HOSTS,
-                                           UTF8ToUTF16(hosts[0]),
-                                           UTF8ToUTF16(hosts[1]));
+                                           UTF8ToUTF16(host_list[0]),
+                                           UTF8ToUTF16(host_list[1]));
       break;
     case 3:
       message_id = kHosts3;
       message = l10n_util::GetStringFUTF16(IDS_EXTENSION_PROMPT_WARNING_3_HOSTS,
-                                           UTF8ToUTF16(hosts[0]),
-                                           UTF8ToUTF16(hosts[1]),
-                                           UTF8ToUTF16(hosts[2]));
+                                           UTF8ToUTF16(host_list[0]),
+                                           UTF8ToUTF16(host_list[1]),
+                                           UTF8ToUTF16(host_list[2]));
       break;
     default:
       message_id = kHosts4OrMore;
       message = l10n_util::GetStringFUTF16(
           IDS_EXTENSION_PROMPT_WARNING_4_OR_MORE_HOSTS,
-          UTF8ToUTF16(hosts[0]),
-          UTF8ToUTF16(hosts[1]),
+          UTF8ToUTF16(host_list[0]),
+          UTF8ToUTF16(host_list[1]),
           base::IntToString16(hosts.size() - 2));
       break;
   }
 
   return ExtensionPermissionMessage(message_id, message);
 }
 
 ExtensionPermissionMessage::ExtensionPermissionMessage(
     ExtensionPermissionMessage::ID id, const string16& message)
   : id_(id), message_(message) {
@@ skipping 308 matching lines @@
   std::set<std::string> apis_str;
   for (ExtensionAPIPermissionSet::const_iterator i = apis_.begin();
        i != apis_.end(); ++i) {
     ExtensionAPIPermission* permission = info->GetByID(*i);
     if (permission)
       apis_str.insert(permission->name());
   }
   return apis_str;
 }
 
-std::vector<std::string>
+std::set<std::string>
     ExtensionPermissionSet::GetDistinctHostsForDisplay() const {
-  return GetDistinctHosts(effective_hosts_.patterns(), true);
+  return GetDistinctHosts(effective_hosts_, true);
 }
 
 ExtensionPermissionMessages
     ExtensionPermissionSet::GetPermissionMessages() const {
   ExtensionPermissionMessages messages;
 
   if (HasEffectiveFullAccess()) {
     messages.push_back(ExtensionPermissionMessage(
         ExtensionPermissionMessage::kFullAccess,
         l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_FULL_ACCESS)));
     return messages;
   }
 
   if (HasEffectiveAccessToAllHosts()) {
     messages.push_back(ExtensionPermissionMessage(
         ExtensionPermissionMessage::kHostsAll,
         l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_ALL_HOSTS)));
   } else {
-    std::vector<std::string> hosts = GetDistinctHostsForDisplay();
+    std::set<std::string> hosts = GetDistinctHostsForDisplay();
     if (!hosts.empty())
       messages.push_back(ExtensionPermissionMessage::CreateFromHostList(hosts));
   }
 
   std::set<ExtensionPermissionMessage> simple_msgs =
       GetSimplePermissionMessages();
   messages.insert(messages.end(), simple_msgs.begin(), simple_msgs.end());
 
   return messages;
 }
@@ skipping 65 matching lines @@
   // We only need to check our host list to verify access. The host list should
   // already reflect any special rules (such as chrome://favicon, component
   // all hosts access, etc.).
   return scriptable_hosts().MatchesURL(origin);
 }
 
 bool ExtensionPermissionSet::HasEffectiveAccessToAllHosts() const {
   // There are two ways this set can have effective access to all hosts:
   //  1) it has an <all_urls> URL pattern.
   //  2) it has a named permission with implied full URL access.
-  const URLPatternList patterns = effective_hosts().patterns();
-  for (URLPatternList::const_iterator host = patterns.begin();
-       host != patterns.end(); ++host) {
+  for (URLPatternSet::const_iterator host = effective_hosts().begin();
+       host != effective_hosts().end(); ++host) {
     if (host->match_all_urls() ||
         (host->match_subdomains() && host->host().empty()))
       return true;
   }
 
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
   for (ExtensionAPIPermissionSet::const_iterator i = apis().begin();
        i != apis().end(); ++i) {
     ExtensionAPIPermission* permission = info->GetByID(*i);
     if (permission->implies_full_url_access())
@@ skipping 42 matching lines @@
   if (HasLessHostPrivilegesThan(permissions))
     return true;
 
   if (HasLessAPIPrivilegesThan(permissions))
     return true;
 
   return false;
 }
 
 // static
-std::vector<std::string> ExtensionPermissionSet::GetDistinctHosts(
-    const URLPatternList& host_patterns, bool include_rcd) {
+std::set<std::string> ExtensionPermissionSet::GetDistinctHosts(
+    const URLPatternSet& host_patterns, bool include_rcd) {
   // Use a vector to preserve order (also faster than a map on small sets).
   // Each item is a host split into two parts: host without RCDs and
   // current best RCD.
   typedef std::vector<std::pair<std::string, std::string> > HostVector;
   HostVector hosts_best_rcd;
-  for (size_t i = 0; i < host_patterns.size(); ++i) {
-    std::string host = host_patterns[i].host();
+  for (URLPatternSet::const_iterator i = host_patterns.begin();
+       i != host_patterns.end(); ++i) {
+    std::string host = i->host();
 
     // Add the subdomain wildcard back to the host, if necessary.
-    if (host_patterns[i].match_subdomains())
+    if (i->match_subdomains())
       host = "*." + host;
 
     // If the host has an RCD, split it off so we can detect duplicates.
     std::string rcd;
     size_t reg_len = net::RegistryControlledDomainService::GetRegistryLength(
         host, false);
     if (reg_len && reg_len != std::string::npos) {
       if (include_rcd)  // else leave rcd empty
         rcd = host.substr(host.size() - reg_len);
       host = host.substr(0, host.size() - reg_len);
     }
 
     // Check if we've already seen this host.
     HostVector::iterator it = hosts_best_rcd.begin();
     for (; it != hosts_best_rcd.end(); ++it) {
       if (it->first == host)
         break;
     }
     // If this host was found, replace the RCD if this one is better.
     if (it != hosts_best_rcd.end()) {
       if (include_rcd && RcdBetterThan(rcd, it->second))
         it->second = rcd;
     } else {  // Previously unseen host, append it.
       hosts_best_rcd.push_back(std::make_pair(host, rcd));
     }
   }
 
   // Build up the final vector by concatenating hosts and RCDs.
-  std::vector<std::string> distinct_hosts;
+  std::set<std::string> distinct_hosts;
   for (HostVector::iterator it = hosts_best_rcd.begin();
        it != hosts_best_rcd.end(); ++it)
-    distinct_hosts.push_back(it->first + it->second);
+    distinct_hosts.insert(it->first + it->second);
   return distinct_hosts;
 }
 
 void ExtensionPermissionSet::InitEffectiveHosts() {
   effective_hosts_.ClearPatterns();
 
   if (HasEffectiveAccessToAllHosts()) {
     URLPattern all_urls(URLPattern::SCHEME_ALL);
-    all_urls.set_match_all_urls(true);
+    all_urls.SetMatchAllURLs(true);
     effective_hosts_.AddPattern(all_urls);
     return;
   }
 
   URLPatternSet::CreateUnion(
       explicit_hosts(), scriptable_hosts(), &effective_hosts_);
 }
 
 void ExtensionPermissionSet::InitImplicitExtensionPermissions(
     const Extension* extension) {
   // Add the implied permissions.
   if (!extension->plugins().empty())
     apis_.insert(ExtensionAPIPermission::kPlugin);
 
   if (!extension->devtools_url().is_empty())
     apis_.insert(ExtensionAPIPermission::kDevtools);
 
   // Add the scriptable hosts.
   for (UserScriptList::const_iterator content_script =
            extension->content_scripts().begin();
        content_script != extension->content_scripts().end(); ++content_script) {
-    URLPatternList::const_iterator pattern =
+    URLPatternSet::const_iterator pattern =
         content_script->url_patterns().begin();
     for (; pattern != content_script->url_patterns().end(); ++pattern)
       scriptable_hosts_.AddPattern(*pattern);
   }
 }
 
 std::set<ExtensionPermissionMessage>
     ExtensionPermissionSet::GetSimplePermissionMessages() const {
   std::set<ExtensionPermissionMessage> messages;
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
@@ skipping 36 matching lines @@
     const ExtensionPermissionSet* permissions) const {
   // If this permission set can access any host, then it can't be elevated.
   if (HasEffectiveAccessToAllHosts())
     return false;
 
   // Likewise, if the other permission set has full host access, then it must be
   // a privilege increase.
   if (permissions->HasEffectiveAccessToAllHosts())
     return true;
 
-  const URLPatternList old_list = effective_hosts().patterns();
-  const URLPatternList new_list = permissions->effective_hosts().patterns();
+  const URLPatternSet& old_list = effective_hosts();
+  const URLPatternSet& new_list = permissions->effective_hosts();
 
   // TODO(jstritar): This is overly conservative with respect to subdomains.
   // For example, going from *.google.com to www.google.com will be
   // considered an elevation, even though it is not (http://crbug.com/65337).
-  std::vector<std::string> new_hosts = GetDistinctHosts(new_list, false);
-  std::vector<std::string> old_hosts = GetDistinctHosts(old_list, false);
-
-  std::set<std::string> old_hosts_set(old_hosts.begin(), old_hosts.end());
-  std::set<std::string> new_hosts_set(new_hosts.begin(), new_hosts.end());
+  std::set<std::string> new_hosts_set = GetDistinctHosts(new_list, false);
+  std::set<std::string> old_hosts_set = GetDistinctHosts(old_list, false);
   std::set<std::string> new_hosts_only;
 
   std::set_difference(new_hosts_set.begin(), new_hosts_set.end(),
                       old_hosts_set.begin(), old_hosts_set.end(),
                       std::inserter(new_hosts_only, new_hosts_only.begin()));
 
   return !new_hosts_only.empty();
 }