Allow extensions on chrome:// URLs, when flag is set and permission is explicitly requested

extensions/common/url_pattern.cc

 // Copyright (c) 2012 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 "extensions/common/url_pattern.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
@@ skipping 93 matching lines @@
   size_t wildcard_index = path.find('*');
   size_t path_last = path.size() - 1;
   DCHECK(wildcard_index == std::string::npos || wildcard_index == path_last);
   return wildcard_index == path_last ? path.substr(0, path_last) : path;
 }
 
 }  // namespace
 
 URLPattern::URLPattern()
     : valid_schemes_(SCHEME_NONE),
+      allowed_schemes_(SCHEME_NONE),
       match_all_urls_(false),
       match_subdomains_(false),
       port_("*") {}
 
 URLPattern::URLPattern(int valid_schemes)
     : valid_schemes_(valid_schemes),
+      allowed_schemes_(valid_schemes),
       match_all_urls_(false),
       match_subdomains_(false),
       port_("*") {}
 
 URLPattern::URLPattern(int valid_schemes, const std::string& pattern)
     // Strict error checking is used, because this constructor is only
     // appropriate when we know |pattern| is valid.
     : valid_schemes_(valid_schemes),
+      allowed_schemes_(valid_schemes),
       match_all_urls_(false),
       match_subdomains_(false),
       port_("*") {
   if (PARSE_SUCCESS != Parse(pattern))
     NOTREACHED() << "URLPattern is invalid: " << pattern;
 }
 
 URLPattern::~URLPattern() {
 }
 
@@ skipping 94 matching lines @@
       return PARSE_ERROR_INVALID_PORT;
     host_ = host_.substr(0, port_pos);
   }
 
   // No other '*' can occur in the host, though. This isn't necessary, but is
   // done as a convenience to developers who might otherwise be confused and
   // think '*' works as a glob in the host.
   if (host_.find('*') != std::string::npos)
     return PARSE_ERROR_INVALID_HOST_WILDCARD;
 
+  SetAllowedSchemes(valid_schemes_);
+
   return PARSE_SUCCESS;
 }
 
 void URLPattern::SetValidSchemes(int valid_schemes) {
   spec_.clear();
   valid_schemes_ = valid_schemes;
 }
 
+void URLPattern::SetAllowedSchemes(int allowed_schemes) {
+  spec_.clear();
+  allowed_schemes_ = allowed_schemes;
+}
+
 void URLPattern::SetHost(const std::string& host) {
   spec_.clear();
   host_ = host;
 }
 
 void URLPattern::SetMatchAllURLs(bool val) {
   spec_.clear();
   match_all_urls_ = val;
 
   if (val) {
@@ skipping 13 matching lines @@
   spec_.clear();
   scheme_ = scheme;
   if (scheme_ == "*") {
     valid_schemes_ &= (SCHEME_HTTP | SCHEME_HTTPS);
   } else if (!IsValidScheme(scheme_)) {
     return false;
   }
   return true;
 }
 
+bool URLPattern::IsAllowedScheme(const std::string& scheme) const {
+  return URLPattern::IsSchemeBitSet(scheme, allowed_schemes_);
+}
+
 bool URLPattern::IsValidScheme(const std::string& scheme) const {
-  if (valid_schemes_ == SCHEME_ALL)
+  return URLPattern::IsSchemeBitSet(scheme, valid_schemes_);
+}
+
+bool URLPattern::IsSchemeBitSet(const std::string& scheme, const int mask) {
+  if (mask == SCHEME_ALL)
     return true;
 
   for (size_t i = 0; i < arraysize(kValidSchemes); ++i) {
-    if (scheme == kValidSchemes[i] && (valid_schemes_ & kValidSchemeMasks[i]))
+    if (scheme == kValidSchemes[i] && (mask & kValidSchemeMasks[i]))
       return true;
   }
 
   return false;
 }
 
 void URLPattern::SetPath(const std::string& path) {
   spec_.clear();
   path_ = path;
   path_escaped_ = path_;
@@ skipping 47 matching lines @@
   if (!MatchesScheme(test_url->scheme()))
     return false;
 
   if (match_all_urls_)
     return true;
 
   return MatchesSecurityOriginHelper(*test_url);
 }
 
 bool URLPattern::MatchesScheme(const std::string& test) const {
-  if (!IsValidScheme(test))
+  if (!IsAllowedScheme(test))
     return false;
 
   return scheme_ == "*" || test == scheme_;
 }
 
 bool URLPattern::MatchesHost(const std::string& host) const {
   std::string test(chrome::kHttpScheme);
   test += content::kStandardSchemeSeparator;
   test += host;
   test += "/";
@@ skipping 164 matching lines @@
   }
 
   return result;
 }
 
 // static
 const char* URLPattern::GetParseResultString(
     URLPattern::ParseResult parse_result) {
   return kParseResultMessages[parse_result];
 }