Add whitelist for extensions to put <all_urls> in externally_connectable

extensions/common/manifest_handlers/externally_connectable.cc

 // Copyright 2014 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/manifest_handlers/externally_connectable.h"
 
 #include <algorithm>
 
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 45 matching lines @@
 }
 
 ExternallyConnectableHandler::~ExternallyConnectableHandler() {
 }
 
 bool ExternallyConnectableHandler::Parse(Extension* extension,
                                          base::string16* error) {
   const base::Value* externally_connectable = NULL;
   CHECK(extension->manifest()->Get(keys::kExternallyConnectable,
                                    &externally_connectable));
+  bool allow_all_urls = PermissionsParser::HasAPIPermission(
+      extension, APIPermission::kExternallyConnectableAllUrls);
+
   std::vector<InstallWarning> install_warnings;
   scoped_ptr<ExternallyConnectableInfo> info =
-      ExternallyConnectableInfo::FromValue(*externally_connectable,
-                                           &install_warnings,
-                                           error);
+      ExternallyConnectableInfo::FromValue(
+          *externally_connectable, allow_all_urls, &install_warnings, error);
   if (!info)
     return false;
   if (!info->matches.is_empty()) {
     PermissionsParser::AddAPIPermission(extension,
                                         APIPermission::kWebConnectable);
   }
   extension->AddInstallWarnings(install_warnings);
   extension->SetManifestData(keys::kExternallyConnectable, info.release());
   return true;
 }
 
 const std::vector<std::string> ExternallyConnectableHandler::Keys() const {
   return SingleKey(keys::kExternallyConnectable);
 }
 
 // static
 ExternallyConnectableInfo* ExternallyConnectableInfo::Get(
     const Extension* extension) {
   return static_cast<ExternallyConnectableInfo*>(
       extension->GetManifestData(keys::kExternallyConnectable));
 }
 
 // static
 scoped_ptr<ExternallyConnectableInfo> ExternallyConnectableInfo::FromValue(
     const base::Value& value,
+    bool allow_all_urls,
     std::vector<InstallWarning>* install_warnings,
     base::string16* error) {
   scoped_ptr<ExternallyConnectable> externally_connectable =
       ExternallyConnectable::FromValue(value, error);
   if (!externally_connectable)
     return scoped_ptr<ExternallyConnectableInfo>();
 
   URLPatternSet matches;
 
   if (externally_connectable->matches) {
     for (std::vector<std::string>::iterator it =
              externally_connectable->matches->begin();
          it != externally_connectable->matches->end();
          ++it) {
       // Safe to use SCHEME_ALL here; externally_connectable gives a page ->
       // extension communication path, not the other way.
       URLPattern pattern(URLPattern::SCHEME_ALL);
       if (pattern.Parse(*it) != URLPattern::PARSE_SUCCESS) {
         *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kErrorInvalidMatchPattern, *it);
         return scoped_ptr<ExternallyConnectableInfo>();
       }
 
+      if (allow_all_urls && pattern.match_all_urls()) {
+        matches.AddPattern(pattern);
+        continue;
+      }
+
       // Wildcard hosts are not allowed.
       if (pattern.host().empty()) {
         // Warning not error for forwards compatibility.
         install_warnings->push_back(
             InstallWarning(ErrorUtils::FormatErrorMessage(
                                errors::kErrorWildcardHostsNotAllowed, *it),
                            keys::kExternallyConnectable,
                            *it));
         continue;
       }
@@ skipping 81 matching lines @@
 }
 
 bool ExternallyConnectableInfo::IdCanConnect(const std::string& id) {
   if (all_ids)
     return true;
   DCHECK(base::STLIsSorted(ids));
   return std::binary_search(ids.begin(), ids.end(), id);
 }
 
 }  // namespace extensions