Fix issue that causes some extensions to be disabled right after installation.

chrome/common/extensions/extension.cc

 // Copyright (c) 2010 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.h"
 
 #include <algorithm>
 
 #include "app/l10n_util.h"
 #include "base/base64.h"
@@ skipping 298 matching lines @@
   std::set<string16> messages;
   std::set<std::string>::const_iterator i;
   for (i = api_permissions().begin(); i != api_permissions().end(); ++i) {
     int message_id = GetPermissionMessageId(*i);
     if (message_id)
       messages.insert(l10n_util::GetStringUTF16(message_id));
   }
   return messages;
 }
 
-std::vector<std::string> Extension::GetDistinctHosts() const {
-  return GetDistinctHosts(GetEffectiveHostPermissions().patterns());
+std::vector<std::string> Extension::GetDistinctHosts(bool include_rcd) const {
+  return GetDistinctHosts(GetEffectiveHostPermissions().patterns(),
+                          include_rcd);
 }
 
 // static
 std::vector<std::string> Extension::GetDistinctHosts(
-    const URLPatternList& host_patterns) {
-
+    const URLPatternList& host_patterns, bool include_rcd) {
   // Vector because we later want to access these by index.
   std::vector<std::string> distinct_hosts;
 
   std::set<std::string> rcd_set;
   for (size_t i = 0; i < host_patterns.size(); ++i) {
     std::string candidate = host_patterns[i].host();
     size_t registry = net::RegistryControlledDomainService::GetRegistryLength(
         candidate, false);
     if (registry && registry != std::string::npos) {
       std::string no_rcd(candidate, 0, candidate.size() - registry);
       if (rcd_set.count(no_rcd))
         continue;
       rcd_set.insert(no_rcd);
+      if (!include_rcd)
+        candidate = no_rcd;
     }
     if (std::find(distinct_hosts.begin(), distinct_hosts.end(), candidate) ==
                   distinct_hosts.end()) {
       distinct_hosts.push_back(candidate);
     }
   }
 
   return distinct_hosts;
 }
 
 string16 Extension::GetHostPermissionMessage() const {
   if (HasEffectiveAccessToAllHosts())
     return l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_ALL_HOSTS);
 
-  std::vector<std::string> hosts = GetDistinctHosts();
+  // Include the RCDs in the distinct hosts to make it easier on the users.

[Erik does not do reviews, 2010/12/03 17:56:42]

buff this comment out a bit:
"...to make it easier for the users to read.  For example, this will display
'*.google.co.uk' rather than '*.google.'"

[jstritar, 2010/12/03 21:52:55]

I ended up removing this comment after switching to GetDistinctHostsForDisplay.

+  std::vector<std::string> hosts = GetDistinctHosts(true);
   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]),
@@ skipping 742 matching lines @@
   // Otherwise, if the new extension has a plugin, it's a privilege increase.
   if (new_extension->HasFullPermissions())
     return true;
 
   // If the extension hadn't been granted access to all hosts in the past, then
   // see if the extension requires more host permissions.
   if (!HasEffectiveAccessToAllHosts(granted_extent, granted_apis)) {
     if (new_extension->HasEffectiveAccessToAllHosts())
       return true;
 
+    // Get the distinct hosts without the RCDs to make sure we get the same
+    // hosts regardless of the URL pattern ordering.
     const ExtensionExtent new_extent =
         new_extension->GetEffectiveHostPermissions();
     std::vector<std::string> new_hosts =
-        GetDistinctHosts(new_extent.patterns());
+        GetDistinctHosts(new_extent.patterns(), false);
     std::vector<std::string> old_hosts =
-        GetDistinctHosts(granted_extent.patterns());
+        GetDistinctHosts(granted_extent.patterns(), 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()));
 
     if (new_hosts_only.size())
@@ skipping 1100 matching lines @@
 UninstalledExtensionInfo::UninstalledExtensionInfo(
     const Extension& extension)
     : extension_id(extension.id()),
       extension_api_permissions(extension.api_permissions()),
       is_theme(extension.is_theme()),
       is_app(extension.is_app()),
       converted_from_user_script(extension.converted_from_user_script()),
       update_url(extension.update_url()) {}
 
 UninstalledExtensionInfo::~UninstalledExtensionInfo() {}