Do not display warnings for file:/// extension permissions.

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"
 #include "base/values.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.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 "content/common/url_constants.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;
@@ skipping 481 matching lines @@
        i != apis_.end(); ++i) {
     ExtensionAPIPermission* permission = info->GetByID(*i);
     if (permission)
       apis_str.insert(permission->name());
   }
   return apis_str;
 }
 
 std::set<std::string>
     ExtensionPermissionSet::GetDistinctHostsForDisplay() const {
-  return GetDistinctHosts(effective_hosts_, true);
+  return GetDistinctHosts(effective_hosts_, true, true);
 }
 
 ExtensionPermissionMessages
     ExtensionPermissionSet::GetPermissionMessages() const {
   ExtensionPermissionMessages messages;
 
   if (HasEffectiveFullAccess()) {
     messages.push_back(ExtensionPermissionMessage(
         ExtensionPermissionMessage::kFullAccess,
         l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_FULL_ACCESS)));
@@ skipping 149 matching lines @@
     return true;
 
   if (HasLessAPIPrivilegesThan(permissions))
     return true;
 
   return false;
 }
 
 // static
 std::set<std::string> ExtensionPermissionSet::GetDistinctHosts(
-    const URLPatternSet& host_patterns, bool include_rcd) {
+    const URLPatternSet& host_patterns,
+    bool include_rcd,
+    bool exclude_file_scheme) {
   // 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 (URLPatternSet::const_iterator i = host_patterns.begin();
        i != host_patterns.end(); ++i) {
+    if (exclude_file_scheme && i->scheme() == chrome::kFileScheme)
+      continue;
+
     std::string host = i->host();
 
     // Add the subdomain wildcard back to the host, if necessary.
     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);
@@ skipping 109 matching lines @@
   // a privilege increase.
   if (permissions->HasEffectiveAccessToAllHosts())
     return true;
 
   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::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_set(GetDistinctHosts(new_list, false, false));
+  std::set<std::string> old_hosts_set(GetDistinctHosts(old_list, false, 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();
 }