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());
+// static
+std::vector<std::string> Extension::GetDistinctHostsForDisplay(
+    const URLPatternList& list) {
+  return GetDistinctHosts(list, true);
+}
+
+// static
+bool Extension::IsElevatedHostList(
+    const URLPatternList& old_list, const URLPatternList& new_list) {
+  // 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).

[Erik does not do reviews, 2010/12/03 23:40:41]

Good point.  This seems straightforward to fix, although I agree it should wait
for another CL.  I think we'd want to add a "MatchesPattern()" method to
URLPattern to test to see if a pattern is a strict superset of another.  As-is,
there isn't a direct way to do this.

+
+  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.size() > 0;
 }
 
 // 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();
+
+    // Add the subdomain wildcard back to the host, if necessary.

[Erik does not do reviews, 2010/12/03 23:40:41]

ah, I see how this happened now.

+    if (host_patterns[i].match_subdomains())
+      candidate = "*." + candidate;
+
     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();
+  std::vector<std::string> hosts = GetDistinctHostsForDisplay(
+      GetEffectiveHostPermissions().patterns());
+
   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 744 matching lines @@
     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;
 
     const ExtensionExtent new_extent =
         new_extension->GetEffectiveHostPermissions();
-    std::vector<std::string> new_hosts =
-        GetDistinctHosts(new_extent.patterns());
-    std::vector<std::string> old_hosts =
-        GetDistinctHosts(granted_extent.patterns());
 
-    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())
+    if (IsElevatedHostList(granted_extent.patterns(), new_extent.patterns()))
       return true;
   }
 
   std::set<std::string> new_apis = new_extension->api_permissions();
   std::set<std::string> new_apis_only;
   std::set_difference(new_apis.begin(), new_apis.end(),
                       granted_apis.begin(), granted_apis.end(),
                       std::inserter(new_apis_only, new_apis_only.begin()));
 
   // Ignore API permissions that don't require user approval when deciding if
@@ skipping 1090 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() {}