Start refractoring extension permissions into ExtensionPermissionSet.

chrome/common/extensions/extension_permission_set.cc

Index: chrome/common/extensions/extension_permission_set.cc
diff --git a/chrome/common/extensions/extension_permission_set.cc b/chrome/common/extensions/extension_permission_set.cc
new file mode 100644
index 0000000000000000000000000000000000000000..44783b664649bfab85291ccd8f87308f201776d9
--- /dev/null
+++ b/chrome/common/extensions/extension_permission_set.cc
@@ -0,0 +1,812 @@
+// 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 <string>
+
+#include "base/memory/singleton.h"
+#include "base/values.h"
+#include "base/string_number_conversions.h"
+#include "base/utf_string_conversions.h"
+#include "chrome/browser/extensions/extension_prefs.h"
+#include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/extension_constants.h"
+#include "chrome/common/extensions/extension_l10n_util.h"
+#include "chrome/common/extensions/url_pattern.h"
+#include "chrome/common/extensions/url_pattern_set.h"
+#include "grit/generated_resources.h"
+#include "net/base/registry_controlled_domain.h"
+#include "ui/base/l10n/l10n_util.h"
+
+namespace {
+
+// Helper for GetDistinctHosts(): com > net > org > everything else.
+bool RcdBetterThan(std::string a, std::string b) {
+  if (a == b)
+    return false;
+  if (a == "com")
+    return true;
+  if (a == "net")
+    return b != "com";
+  if (a == "org")
+    return b != "com" && b != "net";
+  return false;
+}
+
+// Names of API modules that do not require a permission.
+const char kBrowserActionModuleName[] = "browserAction";
+const char kBrowserActionsModuleName[] = "browserActions";
+const char kDevToolsModuleName[] = "devtools";
+const char kExtensionModuleName[] = "extension";
+const char kI18NModuleName[] = "i18n";
+const char kOmniboxModuleName[] = "omnibox";
+const char kPageActionModuleName[] = "pageAction";
+const char kPageActionsModuleName[] = "pageActions";
+const char kTestModuleName[] = "test";
+
+// Names of modules that can be used without listing it in the permissions
+// section of the manifest.
+const char* kNonPermissionModuleNames[] = {
+  kBrowserActionModuleName,
+  kBrowserActionsModuleName,
+  kDevToolsModuleName,
+  kExtensionModuleName,
+  kI18NModuleName,
+  kOmniboxModuleName,
+  kPageActionModuleName,
+  kPageActionsModuleName,
+  kTestModuleName
+};
+const size_t kNumNonPermissionModuleNames =
+    arraysize(kNonPermissionModuleNames);
+
+
+// Names of functions (within modules requiring permissions) that can be used
+// without asking for the module permission. In other words, functions you can
+// use with no permissions specified.
+const char* kNonPermissionFunctionNames[] = {
+  "tabs.create",
+  "tabs.onRemoved",
+  "tabs.remove",
+  "tabs.update",
+};
+const size_t kNumNonPermissionFunctionNames =
+    arraysize(kNonPermissionFunctionNames);
+
+// Aliased to kTabPermission for purposes of API checks, but not allowed
+// in the permissions field of the manifest.
+static const char kWindowPermission[] = "windows";
+
+const char kOldUnlimitedStoragePermission[] = "unlimited_storage";
+const char kWindowsPermission[] = "windows";
+
+} // namespace
+
+//
+// PermissionMessage
+//
+
+ExtensionPermissionMessage::ExtensionPermissionMessage(
+    ExtensionPermissionMessage::MessageId message_id, string16 message)
+    : message_id_(message_id),
+      message_(message) {
+}
+
+// static
+ExtensionPermissionMessage ExtensionPermissionMessage::CreateFromHostList(
+    std::vector<std::string> hosts) {
+  CHECK(hosts.size() > 0);
+  MessageId message_id;
+  string16 message;
+  switch (hosts.size()) {
+    case 1:
+      message_id = ID_HOSTS_1;
+      message = l10n_util::GetStringFUTF16(IDS_EXTENSION_PROMPT_WARNING_1_HOST,
+                                           UTF8ToUTF16(hosts[0]));
+      break;
+    case 2:
+      message_id = ID_HOSTS_2;
+      message = l10n_util::GetStringFUTF16(IDS_EXTENSION_PROMPT_WARNING_2_HOSTS,
+                                           UTF8ToUTF16(hosts[0]),
+                                           UTF8ToUTF16(hosts[1]));
+      break;
+    case 3:
+      message_id = ID_HOSTS_3;
+      message = l10n_util::GetStringFUTF16(IDS_EXTENSION_PROMPT_WARNING_3_HOSTS,
+                                           UTF8ToUTF16(hosts[0]),
+                                           UTF8ToUTF16(hosts[1]),
+                                           UTF8ToUTF16(hosts[2]));
+      break;
+    default:
+      message_id = ID_HOSTS_4_OR_MORE;
+      message = l10n_util::GetStringFUTF16(
+          IDS_EXTENSION_PROMPT_WARNING_4_OR_MORE_HOSTS,
+          UTF8ToUTF16(hosts[0]),
+          UTF8ToUTF16(hosts[1]),
+          base::IntToString16(hosts.size() - 2));
+      break;
+  }
+
+  return ExtensionPermissionMessage(message_id, message);
+}
+
+//
+// ExtensionPermissionsInfo
+//
+
+// static
+ExtensionPermissionsInfo* ExtensionPermissionsInfo::GetInstance() {
+  return Singleton<ExtensionPermissionsInfo>::get();
+}
+
+// TODO(jstritar): Figure out how to clean up this initialization. We may want
+// initialize these dynamically based on data in extension_api.json.
+ExtensionPermissionsInfo::ExtensionPermissionsInfo()

[jstritar, 2011/06/09 21:12:57]

Any advice on how to make these initializations cleaner?

+    : background_(this, "background", true, false, 0,

[Matt Perry, 2011/06/09 22:28:42]

If you take my suggestion and switch to using an enum, I would change this class
to instead keep:
  std::map<ThePermissionEnum, ExtensionApiPermission*> permissions_;

Then do:
  permissions_[kBookmark] = new ExtensionApiPermission("bookmarks", false,
false, IDS_BLA, Message::Bla);

Since there are commonalities between many of these, I'd make a couple helper
functions, like:
RegisterExtensionPermission(kBookmark, "bookmarks", IDS_bla, Message::Bla)
RegisterAppPermission(kClipboardRead, "clipboardRead", IDS_FOO, Message::Foo);
RegisterPrivatePermission(kChromeosInfoPrivate, ...);
and so on.

+                  ExtensionPermissionMessage::ID_NONE),
+      bookmark_(this, "bookmarks",  false, false,
+                IDS_EXTENSION_PROMPT_WARNING_BOOKMARKS,
+                ExtensionPermissionMessage::ID_BOOKMARKS),
+      clipboard_read_(this, "clipboardRead", true, false,
+                      IDS_EXTENSION_PROMPT_WARNING_CLIPBOARD,
+                      ExtensionPermissionMessage::ID_CLIPBOARD),
+      clipboard_write_(this, "clipboardWrite", true, false, 0,
+                       ExtensionPermissionMessage::ID_NONE),
+      content_settings_(this, "contentSettings", false, false, 0,
+                        ExtensionPermissionMessage::ID_NONE),
+      context_menus_(this, "contentSettings", false, false, 0,
+                     ExtensionPermissionMessage::ID_NONE),
+      cookie_(this, "cookies", false, false, 0,
+              ExtensionPermissionMessage::ID_NONE),
+      chrome_private_(this, "chromePrivate", true, false, 0,
+                      ExtensionPermissionMessage::ID_NONE),
+      chromeos_info_private_(this, "chromeosInfoPrivate", false, true, 0,
+                             ExtensionPermissionMessage::ID_NONE),
+      debugger_(this, "debugger", false, false,
+                IDS_EXTENSION_PROMPT_WARNING_DEBUGGER,
+                ExtensionPermissionMessage::ID_DEBUGGER),
+      experimental_(this, "experimental", true, false, 0,
+                    ExtensionPermissionMessage::ID_NONE),
+      file_browser_handler_(this, "fileBrowserHandler", false, false, 0,
+                            ExtensionPermissionMessage::ID_NONE),
+      file_browser_private_(this, "fileBrowserPrivate", false, true, 0,
+                            ExtensionPermissionMessage::ID_NONE),
+      geolocation_(this, "geolocation", true, false,
+                   IDS_EXTENSION_PROMPT_WARNING_GEOLOCATION,
+                   ExtensionPermissionMessage::ID_GEOLOCATION),
+      history_(this, "history", false, false,
+               IDS_EXTENSION_PROMPT_WARNING_BROWSING_HISTORY,
+               ExtensionPermissionMessage::ID_BROWSING_HISTORY),
+      idle_(this, "idle", false, false, 0, ExtensionPermissionMessage::ID_NONE),
+      management_(this, "management", false, false,
+                  IDS_EXTENSION_PROMPT_WARNING_MANAGEMENT,
+                  ExtensionPermissionMessage::ID_MANAGEMENT),
+      media_player_private_(this, "mediaPlayerPrivate", false, true, 0,
+                            ExtensionPermissionMessage::ID_NONE),
+      notification_(this, "notifications", true, false, 0,
+                    ExtensionPermissionMessage::ID_NONE),
+      proxy_(this, "proxy", false, false, 0,
+             ExtensionPermissionMessage::ID_NONE),
+      tab_(this, "tabs", false, false, IDS_EXTENSION_PROMPT_WARNING_TABS,
+           ExtensionPermissionMessage::ID_TABS),
+      unlimited_storage_(this, "unlimitedStorage", true, false, 0,
+                         ExtensionPermissionMessage::ID_NONE),
+      web_socket_proxy_private_(this, "webSocketProxyPrivate", false, false, 0,
+                                ExtensionPermissionMessage::ID_NONE),
+      webstore_private_(this, "webstorePrivate", true, true, 0,
+                        ExtensionPermissionMessage::ID_NONE) {
+
+  // Map aliases for old permissions.
+  permissions_[kOldUnlimitedStoragePermission] = &unlimited_storage_;
+  permissions_[kWindowsPermission] = &tab_;
+}
+
+ExtensionPermissionsInfo::~ExtensionPermissionsInfo() {
+}
+
+//
+// ExtensionPermission
+//
+
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::Background() {
+  return ExtensionPermissionsInfo::GetInstance()->background_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::Bookmark() {
+  return ExtensionPermissionsInfo::GetInstance()->bookmark_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::ClipboardRead() {
+  return ExtensionPermissionsInfo::GetInstance()->clipboard_read_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::ClipboardWrite() {
+  return ExtensionPermissionsInfo::GetInstance()->clipboard_write_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::ContentSettings() {
+  return ExtensionPermissionsInfo::GetInstance()->content_settings_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::ContextMenus() {
+  return ExtensionPermissionsInfo::GetInstance()->context_menus_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::Cookie() {
+  return ExtensionPermissionsInfo::GetInstance()->cookie_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::ChromePrivate() {
+  return ExtensionPermissionsInfo::GetInstance()->chrome_private_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::ChromeosInfoPrivate() {
+  return ExtensionPermissionsInfo::GetInstance()->chromeos_info_private_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::Debugger() {
+  return ExtensionPermissionsInfo::GetInstance()->debugger_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::Experimental() {
+  return ExtensionPermissionsInfo::GetInstance()->experimental_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::FileBrowserHandler() {
+  return ExtensionPermissionsInfo::GetInstance()->file_browser_handler_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::FileBrowserPrivate() {
+  return ExtensionPermissionsInfo::GetInstance()->file_browser_private_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::Geolocation() {
+  return ExtensionPermissionsInfo::GetInstance()->geolocation_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::History() {
+  return ExtensionPermissionsInfo::GetInstance()->history_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::Idle() {
+  return ExtensionPermissionsInfo::GetInstance()->idle_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::Management() {
+  return ExtensionPermissionsInfo::GetInstance()->management_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::MediaPlayerPrivate() {
+  return ExtensionPermissionsInfo::GetInstance()->media_player_private_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::Notification() {
+  return ExtensionPermissionsInfo::GetInstance()->notification_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::Proxy() {
+  return ExtensionPermissionsInfo::GetInstance()->proxy_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::Tab() {
+  return ExtensionPermissionsInfo::GetInstance()->tab_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::UnlimitedStorage() {
+  return ExtensionPermissionsInfo::GetInstance()->unlimited_storage_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::WebstorePrivate() {
+  return ExtensionPermissionsInfo::GetInstance()->webstore_private_;
+}
+
+// static
+const ExtensionAPIPermission& ExtensionAPIPermission::WebSocketProxyPrivate() {
+  return ExtensionPermissionsInfo::GetInstance()->web_socket_proxy_private_;
+}
+
+// static
+std::set<ExtensionAPIPermission> ExtensionAPIPermission::GetAll() {
+  std::set<ExtensionAPIPermission> permissions;
+  ExtensionPermissionsInfo::PermissionMap permission_map =
+      ExtensionPermissionsInfo::GetInstance()->permissions_;
+  ExtensionPermissionsInfo::PermissionMap::const_iterator i =
+      permission_map.begin();
+  for (; i != permission_map.end(); ++i) {
+    permissions.insert(*(i->second));
+  }
+  return permissions;
+}
+
+// static
+ExtensionAPIPermission* ExtensionAPIPermission::GetByName(std::string name) {
+  ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
+  if (info->permissions_.count(name))
+    return info->permissions_.find(name)->second;
+  return NULL;
+}
+
+// static
+std::set<ExtensionAPIPermission> ExtensionAPIPermission::GetAllByName(
+    const std::set<std::string>& permissions_str) {
+  std::set<ExtensionAPIPermission> permissions;
+  for (std::set<std::string>::iterator i = permissions_str.begin();
+       i != permissions_str.end(); ++i) {
+    ExtensionAPIPermission* permission =
+        ExtensionAPIPermission::GetByName(*i);
+    if (permission)
+      permissions.insert(*permission);
+  }
+  return permissions;
+}
+
+// static
+size_t ExtensionAPIPermission::permission_count_ = 0;
+
+// static
+size_t ExtensionAPIPermission::hosted_app_permission_count_ = 0;
+
+ExtensionPermissionMessage ExtensionAPIPermission::GetMessage() const {
+  return ExtensionPermissionMessage(
+      message_id_, l10n_util::GetStringUTF16(l10n_message_id_));
+}
+
+ExtensionAPIPermission::ExtensionAPIPermission(
+    ExtensionPermissionsInfo* info,
+    const char* name,
+    bool is_hosted_app,
+    bool is_component_only,
+    int l10n_message_id,
+    ExtensionPermissionMessage::MessageId message_id)
+    : name_(name),
+      is_hosted_app_(is_hosted_app),
+      is_component_only_(is_component_only),
+      l10n_message_id_(l10n_message_id),
+      message_id_(message_id) {
+  // Update the permission counts when we create a new one.
+  permission_count_++;
+
+  if (is_hosted_app)
+    hosted_app_permission_count_++;
+
+  info->permissions_[name] = this;
+}
+
+ExtensionAPIPermission::~ExtensionAPIPermission() {
+}
+
+bool ExtensionAPIPermission::operator==(
+    const ExtensionAPIPermission& permission) const {
+  return name_ == permission.name_;
+}
+
+bool ExtensionAPIPermission::operator<(
+    const ExtensionAPIPermission& permission) const {
+  return name_ < permission.name_;
+}
+
+//
+// ExtensionPermissionSet
+//
+
+
+ExtensionPermissionSet::ExtensionPermissionSet()
+    : native_code_(false) {
+}
+
+ExtensionPermissionSet::ExtensionPermissionSet(
+    Extension* extension,
+    std::set<ExtensionAPIPermission> apis,
+    URLPatternList hosts) : apis_(apis),
+                            native_code_(false) {
+  InitFromExtension(extension, hosts);
+}
+
+ExtensionPermissionSet::ExtensionPermissionSet(
+    bool native_code,
+    std::set<ExtensionAPIPermission> apis,
+    URLPatternSet effective_hosts) : apis_(apis),
+                                     effective_hosts_(effective_hosts),
+                                     native_code_(native_code) {
+}
+
+ExtensionPermissionSet::~ExtensionPermissionSet() {
+}
+
+// static
+ExtensionPermissionSet* ExtensionPermissionSet::CreateUnion(
+    const ExtensionPermissionSet& set1,
+    const ExtensionPermissionSet& set2) {
+  bool full_access = set1.native_code() || set2.native_code();
+
+  std::set<ExtensionAPIPermission> apis;
+  std::set_union(set1.apis_.begin(), set1.apis_.end(),
+                 set2.apis_.begin(), set2.apis_.end(),
+                 std::insert_iterator<std::set<ExtensionAPIPermission> >(
+                     apis, apis.begin()));
+
+  URLPatternSet new_hosts = set1.effective_hosts_;
+  URLPatternList hosts2 = set2.effective_hosts_.patterns();
+  URLPatternList new_host_list = new_hosts.patterns();
+
+  for (URLPatternList::const_iterator i = hosts2.begin();
+       i != hosts2.end(); ++i) {
+    bool duplicate = false;
+    for (URLPatternList::const_iterator j = new_host_list.begin();
+         j != new_host_list.end(); ++j) {
+      if (j->GetAsString() == i->GetAsString()) {
+        duplicate = true;
+        break;
+      }
+    }
+    if (!duplicate)
+      new_hosts.AddPattern(*i);
+  }
+
+  return new ExtensionPermissionSet(full_access, apis, new_hosts);
+}
+
+// static
+ExtensionPermissionSet* ExtensionPermissionSet::CreateDifference(
+    const ExtensionPermissionSet& set1,
+    const ExtensionPermissionSet& set2) {
+  NOTREACHED();
+  return NULL;
+}
+
+// static
+ExtensionPermissionSet* ExtensionPermissionSet::CreateIntersection(
+    const ExtensionPermissionSet& set1,
+    const ExtensionPermissionSet& set2) {
+  NOTREACHED();
+  return NULL;
+}
+
+bool ExtensionPermissionSet::Contains(
+    const ExtensionPermissionSet& set) const {
+  NOTREACHED();
+  return false;
+}
+
+ExtensionPermissionMessages
+    ExtensionPermissionSet::GetPermissionMessages() const {
+  ExtensionPermissionMessages messages;
+
+  if (native_code_) {
+    messages.push_back(ExtensionPermissionMessage(
+        ExtensionPermissionMessage::ID_FULL_ACCESS,
+        l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_FULL_ACCESS)));
+    return messages;
+  }
+
+  if (HasEffectiveAccessToAllHosts()) {
+    messages.push_back(ExtensionPermissionMessage(
+        ExtensionPermissionMessage::ID_HOSTS_ALL,
+        l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_ALL_HOSTS)));
+  } else {
+    std::vector<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;
+}
+
+std::vector<string16> ExtensionPermissionSet::GetWarningMessages() const {
+  std::vector<string16> messages;
+  ExtensionPermissionMessages permissions = GetPermissionMessages();
+  for (ExtensionPermissionMessages::const_iterator i = permissions.begin();
+       i != permissions.end(); ++i)
+    messages.push_back(i->message());
+  return messages;
+}
+
+bool ExtensionPermissionSet::IsEmpty() const {
+  return !native_code_ && apis_.empty() && effective_hosts_.is_empty();
+}
+
+bool ExtensionPermissionSet::HasAPIPermission(
+    const ExtensionAPIPermission& permission) const {
+  return apis_.count(permission) > 0;
+}
+
+bool ExtensionPermissionSet::HasAccessToFunction(
+    const std::string& function_name) const {
+  // TODO(jstritar): Embed this information in each permission and add a method
+  // like GrantsAccess(function_name) to ExtensionAPIPermission. A "default"
+  // permission can then handle the modules and functions that everyone can
+  // access.
+
+  std::string permission_name = function_name;
+
+  for (size_t i = 0; i < kNumNonPermissionFunctionNames; ++i) {
+    if (permission_name == kNonPermissionFunctionNames[i])
+      return true;
+  }
+
+  // See if this is a function or event name first and strip out the package.
+  // Functions will be of the form package.function
+  // Events will be of the form package/id or package.optional.stuff
+  size_t separator = function_name.find_first_of("./");
+  if (separator != std::string::npos)
+    permission_name = function_name.substr(0, separator);
+
+  ExtensionAPIPermission* permission =
+      ExtensionAPIPermission::GetByName(permission_name);
+  if (permission && apis_.count(*permission))
+    return true;
+
+  for (size_t i = 0; i < kNumNonPermissionModuleNames; ++i) {
+    if (permission_name == kNonPermissionModuleNames[i]) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool ExtensionPermissionSet::HasAccessToHost(const GURL& origin) const {
+  const URLPatternList patterns = effective_hosts_.patterns();
+  for (URLPatternList::const_iterator host = patterns.begin();
+       host != patterns.end(); ++host) {
+    if (host->MatchesURL(origin))
+      return true;
+  }
+
+  return false;
+}
+
+bool ExtensionPermissionSet::HasEffectiveAccessToAllHosts() const {
+  const URLPatternList patterns = effective_hosts_.patterns();
+  for (URLPatternList::const_iterator host = patterns.begin();
+       host != patterns.end(); ++host) {
+    if (host->match_all_urls() ||
+        (host->match_subdomains() && host->host().empty()))
+      return true;
+  }
+
+  return false;
+}
+
+
+bool ExtensionPermissionSet::HasPrivatePermissions() const {
+  for (std::set<ExtensionAPIPermission>::const_iterator i = apis_.begin();
+       i != apis_.end(); ++i) {
+    if (i->is_component_only())
+      return true;
+  }
+  return false;
+}
+
+// static
+std::vector<std::string> ExtensionPermissionSet::GetDistinctHosts(
+    const URLPatternList& 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();
+
+    // Add the subdomain wildcard back to the host, if necessary.
+    if (host_patterns[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;
+  for (HostVector::iterator it = hosts_best_rcd.begin();
+       it != hosts_best_rcd.end(); ++it)
+    distinct_hosts.push_back(it->first + it->second);
+  return distinct_hosts;
+}
+
+void ExtensionPermissionSet::InitFromExtension(
+    Extension* extension,
+    const URLPatternList& hosts_) {
+  native_code_ = !extension->plugins().empty();
+
+  // Initialize the effective host permissions.
+  for (URLPatternList::const_iterator host = hosts_.begin();
+       host != hosts_.end(); ++host)
+    effective_hosts_.AddPattern(*host);
+
+  for (UserScriptList::const_iterator content_script =
+           extension->content_scripts().begin();
+       content_script != extension->content_scripts().end(); ++content_script) {
+    URLPatternList::const_iterator pattern =
+        content_script->url_patterns().begin();
+    for (; pattern != content_script->url_patterns().end(); ++pattern)
+      effective_hosts_.AddPattern(*pattern);
+  }
+
+  if (HasAPIPermission(ExtensionAPIPermission::Proxy()) ||
+      !extension->devtools_url().is_empty()) {
+    URLPattern all_urls(URLPattern::SCHEME_ALL);
+    all_urls.set_match_all_urls(true);
+    effective_hosts_.AddPattern(all_urls);
+  }
+
+}
+
+std::set<std::string> ExtensionPermissionSet::GetAPIsAsStrings() const {
+  std::set<std::string> apis_str;
+  for (std::set<ExtensionAPIPermission>::iterator i = apis_.begin();
+       i != apis_.end(); ++i)
+    apis_str.insert(i->name());
+  return apis_str;
+}
+
+std::vector<std::string>
+    ExtensionPermissionSet::GetDistinctHostsForDisplay() const {
+  return GetDistinctHosts(effective_hosts_.patterns(), true);
+}
+
+string16 ExtensionPermissionSet::GetHostPermissionMessage() const {
+  if (HasEffectiveAccessToAllHosts())
+    return l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_ALL_HOSTS);
+
+  std::vector<std::string> hosts = GetDistinctHostsForDisplay();
+
+  if (hosts.size() == 1) {
+    return l10n_util::GetStringFUTF16(IDS_EXTENSION_PROMPT_WARNING_1_HOST,
+                                      UTF8ToUTF16(hosts[0]));
+  } else if (hosts.size() == 2) {
+    return l10n_util::GetStringFUTF16(IDS_EXTENSION_PROMPT_WARNING_2_HOSTS,
+                                      UTF8ToUTF16(hosts[0]),
+                                      UTF8ToUTF16(hosts[1]));
+  } else if (hosts.size() == 3) {
+    return l10n_util::GetStringFUTF16(IDS_EXTENSION_PROMPT_WARNING_3_HOSTS,
+                                      UTF8ToUTF16(hosts[0]),
+                                      UTF8ToUTF16(hosts[1]),
+                                      UTF8ToUTF16(hosts[2]));
+  } else if (hosts.size() >= 4) {
+    return l10n_util::GetStringFUTF16(
+        IDS_EXTENSION_PROMPT_WARNING_4_OR_MORE_HOSTS,
+        UTF8ToUTF16(hosts[0]),
+        UTF8ToUTF16(hosts[1]),
+        base::IntToString16(hosts.size() - 2));
+  }
+
+  return string16();
+}
+
+std::set<ExtensionPermissionMessage>
+    ExtensionPermissionSet::GetSimplePermissionMessages() const {
+  std::set<ExtensionPermissionMessage> messages;
+  std::set<ExtensionAPIPermission>::const_iterator i;
+  for (i = apis_.begin(); i != apis_.end(); ++i) {
+    DCHECK_GT(ExtensionPermissionMessage::ID_NONE,
+              ExtensionPermissionMessage::ID_UNKNOWN);
+    if (i->message_id() > ExtensionPermissionMessage::ID_NONE)
+      messages.insert(i->GetMessage());
+  }
+  return messages;
+}
+
+bool ExtensionPermissionSet::HasLessAPIPrivilegesThan(
+    const ExtensionPermissionSet& permissions) {
+  std::set<ExtensionAPIPermission> new_apis = permissions.apis_;
+  std::set<ExtensionAPIPermission> new_apis_only;
+  std::set_difference(new_apis.begin(), new_apis.end(),
+                      apis_.begin(), apis_.end(),
+                      std::inserter(new_apis_only, new_apis_only.begin()));
+
+  // Ignore API permissions that don't require user approval when deciding if
+  // an extension has increased its privileges.
+  size_t new_api_count = 0;
+  for (std::set<ExtensionAPIPermission>::iterator i = new_apis_only.begin();
+       i != new_apis_only.end(); ++i) {
+    if (i->message_id() > ExtensionPermissionMessage::ID_NONE)
+      new_api_count++;
+  }
+
+  return new_api_count > 0;
+}
+
+bool ExtensionPermissionSet::HasLessHostPrivilegesThan(
+    const ExtensionPermissionSet& permissions) {
+  // 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();
+
+  // 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_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();
+}
+
+bool ExtensionPermissionSet::HasLessPrivilegesThan(
+    const ExtensionPermissionSet& permissions) {
+  // Things can't get worse native code access.
+  if (native_code_)
+    return false;
+
+  // Otherwise, it's a privilege increase if the new one has full access.
+  if (permissions.native_code_)
+    return true;
+
+  if (HasLessHostPrivilegesThan(permissions))
+    return true;
+
+  if (HasLessAPIPrivilegesThan(permissions))
+    return true;
+
+  return false;
+
+}