Turn disallowed URL patterns such as <all_urls> for externally_connectable into

chrome/common/extensions/manifest_handlers/externally_connectable_unittest.cc

 // Copyright 2013 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 <algorithm>
 
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/features/feature.h"
 #include "chrome/common/extensions/manifest_handlers/externally_connectable.h"
 #include "chrome/common/extensions/manifest_tests/extension_manifest_test.h"
 #include "extensions/common/error_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::ElementsAre;
 
 namespace extensions {
 
 namespace errors = externally_connectable_errors;
 
 class ExternallyConnectableTest : public ExtensionManifestTest {
  public:
   ExternallyConnectableTest() : channel_(chrome::VersionInfo::CHANNEL_DEV) {}
 
+ protected:
+  ExternallyConnectableInfo* GetExternallyConnectableInfo(
+      scoped_refptr<Extension> extension) {
+    return static_cast<ExternallyConnectableInfo*>(extension->GetManifestData(
+        extension_manifest_keys::kExternallyConnectable));
+  }
+
  private:
   Feature::ScopedCurrentChannel channel_;
 };
 
 TEST_F(ExternallyConnectableTest, IDsAndMatches) {
   scoped_refptr<Extension> extension =
       LoadAndExpectSuccess("externally_connectable_ids_and_matches.json");
   ASSERT_TRUE(extension.get());
 
   EXPECT_TRUE(extension->HasAPIPermission(APIPermission::kWebConnectable));
@@ skipping 150 matching lines @@
   {
     ExternallyConnectableInfo info(URLPatternSet(), matches_ids, true);
     for (size_t i = 0; i < matches_ids.size(); ++i)
       EXPECT_TRUE(info.IdCanConnect(matches_ids[i]));
     for (size_t i = 0; i < arraysize(nomatches_ids_array); ++i)
       EXPECT_TRUE(info.IdCanConnect(nomatches_ids_array[i]));
   }
 }
 
 TEST_F(ExternallyConnectableTest, ErrorWrongFormat) {
-  RunTestcase(Testcase("externally_connectable_error_wrong_format.json",
-                       errors::kErrorInvalid),
-              EXPECT_TYPE_ERROR);
+  LoadAndExpectError("externally_connectable_error_wrong_format.json",
+                     errors::kErrorInvalid);
 }
 
 TEST_F(ExternallyConnectableTest, ErrorBadID) {
-  RunTestcase(Testcase("externally_connectable_bad_id.json",
-                       ErrorUtils::FormatErrorMessage(errors::kErrorInvalidId,
-                                                      "badid")),
-              EXPECT_TYPE_ERROR);
+  LoadAndExpectError(
+      "externally_connectable_bad_id.json",
+      ErrorUtils::FormatErrorMessage(errors::kErrorInvalidId, "badid"));
 }
 
 TEST_F(ExternallyConnectableTest, ErrorBadMatches) {
-  RunTestcase(
-      Testcase("externally_connectable_error_bad_matches.json",
-               ErrorUtils::FormatErrorMessage(errors::kErrorInvalidMatchPattern,
-                                              "www.yahoo.com")),
-      EXPECT_TYPE_ERROR);
+  LoadAndExpectError(
+      "externally_connectable_error_bad_matches.json",
+      ErrorUtils::FormatErrorMessage(errors::kErrorInvalidMatchPattern,
+                                     "www.yahoo.com"));
 }
 
-TEST_F(ExternallyConnectableTest, ErrorNoAllURLs) {
-  RunTestcase(
-      Testcase(
-          "externally_connectable_error_all_urls.json",
-          ErrorUtils::FormatErrorMessage(errors::kErrorWildcardHostsNotAllowed,
-                                         "<all_urls>")),
-      EXPECT_TYPE_ERROR);
+TEST_F(ExternallyConnectableTest, WarningNoAllURLs) {
+  scoped_refptr<Extension> extension = LoadAndExpectWarning(
+      "externally_connectable_error_all_urls.json",
+      ErrorUtils::FormatErrorMessage(errors::kErrorWildcardHostsNotAllowed,
+                                     "<all_urls>"));
+  ExternallyConnectableInfo* info = GetExternallyConnectableInfo(extension);
+  EXPECT_FALSE(info->matches.ContainsPattern(
+      URLPattern(URLPattern::SCHEME_ALL, "<all_urls>")));
+  EXPECT_TRUE(info->matches.MatchesURL(GURL("https://example.com")));
+  EXPECT_TRUE(info->matches.MatchesURL(GURL("http://build.chromium.org")));
 }
 
-TEST_F(ExternallyConnectableTest, ErrorWildcardHost) {
-  RunTestcase(
-      Testcase(
-          "externally_connectable_error_wildcard_host.json",
-          ErrorUtils::FormatErrorMessage(errors::kErrorWildcardHostsNotAllowed,
-                                         "http://*/*")),
-      EXPECT_TYPE_ERROR);
+TEST_F(ExternallyConnectableTest, WarningWildcardHost) {
+  scoped_refptr<Extension> extension = LoadAndExpectWarning(
+      "externally_connectable_error_wildcard_host.json",
+      ErrorUtils::FormatErrorMessage(errors::kErrorWildcardHostsNotAllowed,
+                                     "http://*/*"));
+  ExternallyConnectableInfo* info = GetExternallyConnectableInfo(extension);
+  EXPECT_FALSE(info->matches.ContainsPattern(
+      URLPattern(URLPattern::SCHEME_ALL, "http://*/*")));
+  EXPECT_TRUE(info->matches.MatchesURL(GURL("https://example.com")));
+  EXPECT_TRUE(info->matches.MatchesURL(GURL("http://build.chromium.org")));
 }
 
-TEST_F(ExternallyConnectableTest, ErrorNoTLD) {
-  RunTestcase(
-      Testcase(
-          "externally_connectable_error_tld.json",
-          ErrorUtils::FormatErrorMessage(
-              errors::kErrorTopLevelDomainsNotAllowed,
-              "co.uk",
-              "http://*.co.uk/*")),
-      EXPECT_TYPE_ERROR);
+TEST_F(ExternallyConnectableTest, WarningNoTLD) {
+  scoped_refptr<Extension> extension = LoadAndExpectWarning(
+      "externally_connectable_error_tld.json",
+      ErrorUtils::FormatErrorMessage(
+          errors::kErrorTopLevelDomainsNotAllowed,
+          "co.uk",
+          "http://*.co.uk/*"));
+  ExternallyConnectableInfo* info = GetExternallyConnectableInfo(extension);
+  EXPECT_FALSE(info->matches.ContainsPattern(
+      URLPattern(URLPattern::SCHEME_ALL, "http://*.co.uk/*")));
+  EXPECT_TRUE(info->matches.MatchesURL(GURL("https://example.com")));
+  EXPECT_TRUE(info->matches.MatchesURL(GURL("http://build.chromium.org")));
 }
 
-TEST_F(ExternallyConnectableTest, ErrorNoEffectiveTLD) {
-  RunTestcase(
-      Testcase(
-          "externally_connectable_error_effective_tld.json",
-          ErrorUtils::FormatErrorMessage(
-              errors::kErrorTopLevelDomainsNotAllowed,
-              "appspot.com",
-              "http://*.appspot.com/*")),
-      EXPECT_TYPE_ERROR);
+TEST_F(ExternallyConnectableTest, WarningNoEffectiveTLD) {
+  scoped_refptr<Extension> extension = LoadAndExpectWarning(
+      "externally_connectable_error_effective_tld.json",
+      ErrorUtils::FormatErrorMessage(
+          errors::kErrorTopLevelDomainsNotAllowed,
+          "appspot.com",
+          "http://*.appspot.com/*"));
+  ExternallyConnectableInfo* info = GetExternallyConnectableInfo(extension);
+  EXPECT_FALSE(info->matches.ContainsPattern(
+      URLPattern(URLPattern::SCHEME_ALL, "http://*.appspot.com/*")));
+  EXPECT_TRUE(info->matches.MatchesURL(GURL("https://example.com")));
+  EXPECT_TRUE(info->matches.MatchesURL(GURL("http://build.chromium.org")));
 }
 
-TEST_F(ExternallyConnectableTest, ErrorUnknownTLD) {
-  RunTestcase(
-      Testcase(
-          "externally_connectable_error_unknown_tld.json",
-          ErrorUtils::FormatErrorMessage(
-              errors::kErrorTopLevelDomainsNotAllowed,
-              "notatld",
-              "http://*.notatld/*")),
-      EXPECT_TYPE_ERROR);
+TEST_F(ExternallyConnectableTest, WarningUnknownTLD) {
+  scoped_refptr<Extension> extension = LoadAndExpectWarning(
+      "externally_connectable_error_unknown_tld.json",
+      ErrorUtils::FormatErrorMessage(
+          errors::kErrorTopLevelDomainsNotAllowed,
+          "notatld",
+          "http://*.notatld/*"));
+  ExternallyConnectableInfo* info = GetExternallyConnectableInfo(extension);
+  EXPECT_FALSE(info->matches.ContainsPattern(
+      URLPattern(URLPattern::SCHEME_ALL, "http://*.notatld/*")));
+  EXPECT_TRUE(info->matches.MatchesURL(GURL("https://example.com")));
+  EXPECT_TRUE(info->matches.MatchesURL(GURL("http://build.chromium.org")));
 }
 
 }  // namespace extensions