Reland: Communicate ExtensionSettings policy to renderers

extensions/common/url_pattern_unittest.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 <stddef.h>
 
 #include <memory>
 
@@ skipping 10 matching lines @@
     URLPattern::SCHEME_FILE | URLPattern::SCHEME_FTP |
     URLPattern::SCHEME_CHROMEUI | URLPattern::SCHEME_EXTENSION |
     URLPattern::SCHEME_FILESYSTEM | URLPattern::SCHEME_WS |
     URLPattern::SCHEME_WSS;
 
 TEST(ExtensionURLPatternTest, ParseInvalid) {
   const struct {
     const char* pattern;
     URLPattern::ParseResult expected_result;
   } kInvalidPatterns[] = {
-    { "http", URLPattern::PARSE_ERROR_MISSING_SCHEME_SEPARATOR },
-    { "http:", URLPattern::PARSE_ERROR_WRONG_SCHEME_SEPARATOR },
-    { "http:/", URLPattern::PARSE_ERROR_WRONG_SCHEME_SEPARATOR },
-    { "about://", URLPattern::PARSE_ERROR_WRONG_SCHEME_SEPARATOR },
-    { "http://", URLPattern::PARSE_ERROR_EMPTY_HOST },
-    { "http:///", URLPattern::PARSE_ERROR_EMPTY_HOST },
-    { "http:// /", URLPattern::PARSE_ERROR_EMPTY_HOST },
-    { "http://*foo/bar", URLPattern::PARSE_ERROR_INVALID_HOST_WILDCARD },
-    { "http://foo.*.bar/baz", URLPattern::PARSE_ERROR_INVALID_HOST_WILDCARD },
-    { "http://fo.*.ba:123/baz", URLPattern::PARSE_ERROR_INVALID_HOST_WILDCARD },
-    { "http:/bar", URLPattern::PARSE_ERROR_WRONG_SCHEME_SEPARATOR },
-    { "http://bar", URLPattern::PARSE_ERROR_EMPTY_PATH },
-  };
+      {"http", URLPattern::PARSE_ERROR_MISSING_SCHEME_SEPARATOR},
+      {"http:", URLPattern::PARSE_ERROR_WRONG_SCHEME_SEPARATOR},
+      {"http:/", URLPattern::PARSE_ERROR_WRONG_SCHEME_SEPARATOR},
+      {"about://", URLPattern::PARSE_ERROR_WRONG_SCHEME_SEPARATOR},
+      {"http://", URLPattern::PARSE_ERROR_EMPTY_HOST},
+      {"http:///", URLPattern::PARSE_ERROR_EMPTY_HOST},
+      {"http:// /", URLPattern::PARSE_ERROR_EMPTY_HOST},
+      {"http://*foo/bar", URLPattern::PARSE_ERROR_INVALID_HOST_WILDCARD},
+      {"http://foo.*.bar/baz", URLPattern::PARSE_ERROR_INVALID_HOST_WILDCARD},
+      {"http://fo.*.ba:123/baz", URLPattern::PARSE_ERROR_INVALID_HOST_WILDCARD},
+      {"http:/bar", URLPattern::PARSE_ERROR_WRONG_SCHEME_SEPARATOR},
+      {"http://bar", URLPattern::PARSE_ERROR_EMPTY_PATH},
+      {"http://foo.*/bar", URLPattern::PARSE_ERROR_INVALID_HOST_WILDCARD}};
 
   for (size_t i = 0; i < arraysize(kInvalidPatterns); ++i) {
     URLPattern pattern(URLPattern::SCHEME_ALL);
     EXPECT_EQ(kInvalidPatterns[i].expected_result,
               pattern.Parse(kInvalidPatterns[i].pattern))
         << kInvalidPatterns[i].pattern;
   }
 
   {
     // Cannot use a C string, because this contains a null byte.
     std::string null_host("http://\0www/", 12);
     URLPattern pattern(URLPattern::SCHEME_ALL);
     EXPECT_EQ(URLPattern::PARSE_ERROR_INVALID_HOST,
               pattern.Parse(null_host))
         << null_host;
   }
 }
 
 TEST(ExtensionURLPatternTest, Ports) {
   const struct {
     const char* pattern;
     URLPattern::ParseResult expected_result;
     const char* expected_port;
   } kTestPatterns[] = {
-    { "http://foo:1234/", URLPattern::PARSE_SUCCESS, "1234" },
-    { "http://foo:1234/bar", URLPattern::PARSE_SUCCESS, "1234" },
-    { "http://*.foo:1234/", URLPattern::PARSE_SUCCESS, "1234" },
-    { "http://*.foo:1234/bar", URLPattern::PARSE_SUCCESS, "1234" },
-    { "http://:1234/", URLPattern::PARSE_SUCCESS, "1234" },
-    { "http://foo:/", URLPattern::PARSE_ERROR_INVALID_PORT, "*" },
-    { "http://foo:*/", URLPattern::PARSE_SUCCESS, "*" },
-    { "http://*.foo:/", URLPattern::PARSE_ERROR_INVALID_PORT, "*" },
-    { "http://foo:com/", URLPattern::PARSE_ERROR_INVALID_PORT, "*" },
-    { "http://foo:123456/", URLPattern::PARSE_ERROR_INVALID_PORT, "*" },
-    { "http://foo:80:80/monkey", URLPattern::PARSE_ERROR_INVALID_PORT, "*" },
-    { "file://foo:1234/bar", URLPattern::PARSE_SUCCESS, "*" },
-    { "chrome://foo:1234/bar", URLPattern::PARSE_ERROR_INVALID_PORT, "*" },
+      {"http://foo:1234/", URLPattern::PARSE_SUCCESS, "1234"},
+      {"http://foo:1234/bar", URLPattern::PARSE_SUCCESS, "1234"},
+      {"http://*.foo:1234/", URLPattern::PARSE_SUCCESS, "1234"},
+      {"http://*.foo:1234/bar", URLPattern::PARSE_SUCCESS, "1234"},
+      {"http://:1234/", URLPattern::PARSE_SUCCESS, "1234"},
+      {"http://foo:/", URLPattern::PARSE_ERROR_INVALID_PORT, "*"},
+      {"http://foo:*/", URLPattern::PARSE_SUCCESS, "*"},
+      {"http://*.foo:/", URLPattern::PARSE_ERROR_INVALID_PORT, "*"},
+      {"http://foo:com/", URLPattern::PARSE_ERROR_INVALID_PORT, "*"},
+      {"http://foo:123456/", URLPattern::PARSE_ERROR_INVALID_PORT, "*"},
+      {"http://foo:80:80/monkey", URLPattern::PARSE_ERROR_INVALID_PORT, "*"},
+      {"file://foo:1234/bar", URLPattern::PARSE_SUCCESS, "*"},
+      {"chrome://foo:1234/bar", URLPattern::PARSE_ERROR_INVALID_PORT, "*"},
 
-    // Port-like strings in the path should not trigger a warning.
-    { "http://*/:1234", URLPattern::PARSE_SUCCESS, "*" },
-    { "http://*.foo/bar:1234", URLPattern::PARSE_SUCCESS, "*" },
-    { "http://foo/bar:1234/path", URLPattern::PARSE_SUCCESS, "*" },
-  };
+      // Port-like strings in the path should not trigger a warning.
+      {"http://*/:1234", URLPattern::PARSE_SUCCESS, "*"},
+      {"http://*.foo/bar:1234", URLPattern::PARSE_SUCCESS, "*"},
+      {"http://foo/bar:1234/path", URLPattern::PARSE_SUCCESS, "*"},
+      {"http://*.foo.*/:1234", URLPattern::PARSE_SUCCESS, "*"}};
 
   for (size_t i = 0; i < arraysize(kTestPatterns); ++i) {
     URLPattern pattern(URLPattern::SCHEME_ALL);
     EXPECT_EQ(kTestPatterns[i].expected_result,
-              pattern.Parse(kTestPatterns[i].pattern))
+              pattern.Parse(kTestPatterns[i].pattern,
+                            URLPattern::ALLOW_WILDCARD_FOR_EFFECTIVE_TLD))
         << "Got unexpected result for URL pattern: "
         << kTestPatterns[i].pattern;
     EXPECT_EQ(kTestPatterns[i].expected_port, pattern.port())
         << "Got unexpected port for URL pattern: " << kTestPatterns[i].pattern;
   }
 }
 
 // all pages for a given scheme
 TEST(ExtensionURLPatternTest, Match1) {
   URLPattern pattern(kAllSchemes);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("http://*/*"));
   EXPECT_EQ("http", pattern.scheme());
   EXPECT_EQ("", pattern.host());
   EXPECT_TRUE(pattern.match_subdomains());
+  EXPECT_TRUE(pattern.match_effective_tld());
   EXPECT_FALSE(pattern.match_all_urls());
   EXPECT_EQ("/*", pattern.path());
   EXPECT_TRUE(pattern.MatchesURL(GURL("http://google.com")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("http://yahoo.com")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("http://google.com/foo")));
   EXPECT_FALSE(pattern.MatchesURL(GURL("https://google.com")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("http://74.125.127.100/search")));
 }
 
 // all domains
 TEST(ExtensionURLPatternTest, Match2) {
   URLPattern pattern(kAllSchemes);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("https://*/foo*"));
   EXPECT_EQ("https", pattern.scheme());
   EXPECT_EQ("", pattern.host());
   EXPECT_TRUE(pattern.match_subdomains());
+  EXPECT_TRUE(pattern.match_effective_tld());
   EXPECT_FALSE(pattern.match_all_urls());
   EXPECT_EQ("/foo*", pattern.path());
   EXPECT_TRUE(pattern.MatchesURL(GURL("https://www.google.com/foo")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("https://www.google.com/foobar")));
   EXPECT_FALSE(pattern.MatchesURL(GURL("http://www.google.com/foo")));
   EXPECT_FALSE(pattern.MatchesURL(GURL("https://www.google.com/")));
   EXPECT_TRUE(pattern.MatchesURL(
       GURL("filesystem:https://www.google.com/foobar/")));
 }
 
 // subdomains
 TEST(URLPatternTest, Match3) {
   URLPattern pattern(kAllSchemes);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS,
             pattern.Parse("http://*.google.com/foo*bar"));
   EXPECT_EQ("http", pattern.scheme());
   EXPECT_EQ("google.com", pattern.host());
   EXPECT_TRUE(pattern.match_subdomains());
+  EXPECT_TRUE(pattern.match_effective_tld());
   EXPECT_FALSE(pattern.match_all_urls());
   EXPECT_EQ("/foo*bar", pattern.path());
   EXPECT_TRUE(pattern.MatchesURL(GURL("http://google.com/foobar")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("http://www.google.com/foo?bar")));
   EXPECT_TRUE(pattern.MatchesURL(
       GURL("http://monkey.images.google.com/foooobar")));
   EXPECT_FALSE(pattern.MatchesURL(GURL("http://yahoo.com/foobar")));
   EXPECT_TRUE(pattern.MatchesURL(
       GURL("filesystem:http://google.com/foo/bar")));
   EXPECT_FALSE(pattern.MatchesURL(
       GURL("filesystem:http://google.com/temporary/foobar")));
 }
 
 // glob escaping
 TEST(ExtensionURLPatternTest, Match5) {
   URLPattern pattern(kAllSchemes);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("file:///foo?bar\\*baz"));
   EXPECT_EQ("file", pattern.scheme());
   EXPECT_EQ("", pattern.host());
   EXPECT_FALSE(pattern.match_subdomains());
+  EXPECT_TRUE(pattern.match_effective_tld());
   EXPECT_FALSE(pattern.match_all_urls());
   EXPECT_EQ("/foo?bar\\*baz", pattern.path());
   EXPECT_TRUE(pattern.MatchesURL(GURL("file:///foo?bar\\hellobaz")));
   EXPECT_FALSE(pattern.MatchesURL(GURL("file:///fooXbar\\hellobaz")));
 }
 
 // ip addresses
 TEST(ExtensionURLPatternTest, Match6) {
   URLPattern pattern(kAllSchemes);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("http://127.0.0.1/*"));
   EXPECT_EQ("http", pattern.scheme());
   EXPECT_EQ("127.0.0.1", pattern.host());
   EXPECT_FALSE(pattern.match_subdomains());
+  EXPECT_TRUE(pattern.match_effective_tld());
   EXPECT_FALSE(pattern.match_all_urls());
   EXPECT_EQ("/*", pattern.path());
   EXPECT_TRUE(pattern.MatchesURL(GURL("http://127.0.0.1")));
 }
 
 // subdomain matching with ip addresses
 TEST(ExtensionURLPatternTest, Match7) {
   URLPattern pattern(kAllSchemes);
   // allowed, but useless
   EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("http://*.0.0.1/*"));
   EXPECT_EQ("http", pattern.scheme());
   EXPECT_EQ("0.0.1", pattern.host());
   EXPECT_TRUE(pattern.match_subdomains());
+  EXPECT_TRUE(pattern.match_effective_tld());
   EXPECT_FALSE(pattern.match_all_urls());
   EXPECT_EQ("/*", pattern.path());
   // Subdomain matching is never done if the argument has an IP address host.
   EXPECT_FALSE(pattern.MatchesURL(GURL("http://127.0.0.1")));
 }
 
 // unicode
 TEST(ExtensionURLPatternTest, Match8) {
   URLPattern pattern(kAllSchemes);
   // The below is the ASCII encoding of the following URL:
   // http://*.\xe1\x80\xbf/a\xc2\x81\xe1*
   EXPECT_EQ(URLPattern::PARSE_SUCCESS,
             pattern.Parse("http://*.xn--gkd/a%C2%81%E1*"));
   EXPECT_EQ("http", pattern.scheme());
   EXPECT_EQ("xn--gkd", pattern.host());
   EXPECT_TRUE(pattern.match_subdomains());
+  EXPECT_TRUE(pattern.match_effective_tld());
   EXPECT_FALSE(pattern.match_all_urls());
   EXPECT_EQ("/a%C2%81%E1*", pattern.path());
   EXPECT_TRUE(pattern.MatchesURL(
       GURL("http://abc.\xe1\x80\xbf/a\xc2\x81\xe1xyz")));
   EXPECT_TRUE(pattern.MatchesURL(
       GURL("http://\xe1\x80\xbf/a\xc2\x81\xe1\xe1")));
 }
 
 // chrome://
 TEST(ExtensionURLPatternTest, Match9) {
   URLPattern pattern(kAllSchemes);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("chrome://favicon/*"));
   EXPECT_EQ("chrome", pattern.scheme());
   EXPECT_EQ("favicon", pattern.host());
   EXPECT_FALSE(pattern.match_subdomains());
+  EXPECT_TRUE(pattern.match_effective_tld());
   EXPECT_FALSE(pattern.match_all_urls());
   EXPECT_EQ("/*", pattern.path());
   EXPECT_TRUE(pattern.MatchesURL(GURL("chrome://favicon/http://google.com")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("chrome://favicon/https://google.com")));
   EXPECT_FALSE(pattern.MatchesURL(GURL("chrome://history")));
 }
 
 // *://
 TEST(ExtensionURLPatternTest, Match10) {
   URLPattern pattern(kAllSchemes);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("*://*/*"));
   EXPECT_TRUE(pattern.MatchesScheme("http"));
   EXPECT_TRUE(pattern.MatchesScheme("https"));
   EXPECT_FALSE(pattern.MatchesScheme("chrome"));
   EXPECT_FALSE(pattern.MatchesScheme("file"));
   EXPECT_FALSE(pattern.MatchesScheme("ftp"));
   EXPECT_TRUE(pattern.match_subdomains());
+  EXPECT_TRUE(pattern.match_effective_tld());
   EXPECT_FALSE(pattern.match_all_urls());
   EXPECT_EQ("/*", pattern.path());
   EXPECT_TRUE(pattern.MatchesURL(GURL("http://127.0.0.1")));
   EXPECT_FALSE(pattern.MatchesURL(GURL("chrome://favicon/http://google.com")));
   EXPECT_FALSE(pattern.MatchesURL(GURL("file:///foo/bar")));
   EXPECT_FALSE(pattern.MatchesURL(GURL("file://localhost/foo/bar")));
 }
 
 // <all_urls>
 TEST(ExtensionURLPatternTest, Match11) {
   URLPattern pattern(kAllSchemes);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("<all_urls>"));
   EXPECT_TRUE(pattern.MatchesScheme("chrome"));
   EXPECT_TRUE(pattern.MatchesScheme("http"));
   EXPECT_TRUE(pattern.MatchesScheme("https"));
   EXPECT_TRUE(pattern.MatchesScheme("file"));
   EXPECT_TRUE(pattern.MatchesScheme("filesystem"));
   EXPECT_TRUE(pattern.MatchesScheme("chrome-extension"));
   EXPECT_TRUE(pattern.match_subdomains());
+  EXPECT_TRUE(pattern.match_effective_tld());
   EXPECT_TRUE(pattern.match_all_urls());
   EXPECT_EQ("/*", pattern.path());
   EXPECT_TRUE(pattern.MatchesURL(GURL("chrome://favicon/http://google.com")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("http://127.0.0.1")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("file:///foo/bar")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("file://localhost/foo/bar")));
 
   // Make sure the properties are the same when creating an <all_urls> pattern
   // via SetMatchAllURLs and by parsing <all_urls>.
   URLPattern pattern2(kAllSchemes);
@@ skipping 15 matching lines @@
   EXPECT_TRUE(pattern.MatchesScheme("chrome"));
   EXPECT_TRUE(pattern.MatchesScheme("http"));
   EXPECT_TRUE(pattern.MatchesScheme("https"));
   EXPECT_TRUE(pattern.MatchesScheme("file"));
   EXPECT_TRUE(pattern.MatchesScheme("filesystem"));
   EXPECT_TRUE(pattern.MatchesScheme("javascript"));
   EXPECT_TRUE(pattern.MatchesScheme("data"));
   EXPECT_TRUE(pattern.MatchesScheme("about"));
   EXPECT_TRUE(pattern.MatchesScheme("chrome-extension"));
   EXPECT_TRUE(pattern.match_subdomains());
+  EXPECT_TRUE(pattern.match_effective_tld());
   EXPECT_TRUE(pattern.match_all_urls());
   EXPECT_EQ("/*", pattern.path());
   EXPECT_TRUE(pattern.MatchesURL(GURL("chrome://favicon/http://google.com")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("http://127.0.0.1")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("file:///foo/bar")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("file://localhost/foo/bar")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("chrome://newtab")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("about:blank")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("about:version")));
   EXPECT_TRUE(pattern.MatchesURL(
@@ skipping 31 matching lines @@
 }
 
 // file scheme with empty hostname
 TEST(ExtensionURLPatternTest, Match14) {
   URLPattern pattern(kAllSchemes);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("file:///foo*"));
   EXPECT_EQ("file", pattern.scheme());
   EXPECT_EQ("", pattern.host());
   EXPECT_FALSE(pattern.match_subdomains());
   EXPECT_FALSE(pattern.match_all_urls());
+  EXPECT_TRUE(pattern.match_effective_tld());
   EXPECT_EQ("/foo*", pattern.path());
   EXPECT_FALSE(pattern.MatchesURL(GURL("file://foo")));
   EXPECT_FALSE(pattern.MatchesURL(GURL("file://foobar")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("file:///foo")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("file:///foobar")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("file://localhost/foo")));
 }
 
 // file scheme without hostname part
 TEST(ExtensionURLPatternTest, Match15) {
   URLPattern pattern(kAllSchemes);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("file://foo*"));
   EXPECT_EQ("file", pattern.scheme());
   EXPECT_EQ("", pattern.host());
   EXPECT_FALSE(pattern.match_subdomains());
   EXPECT_FALSE(pattern.match_all_urls());
+  EXPECT_TRUE(pattern.match_effective_tld());
   EXPECT_EQ("/foo*", pattern.path());
   EXPECT_FALSE(pattern.MatchesURL(GURL("file://foo")));
   EXPECT_FALSE(pattern.MatchesURL(GURL("file://foobar")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("file:///foo")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("file:///foobar")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("file://localhost/foo")));
 }
 
 // file scheme with hostname
 TEST(ExtensionURLPatternTest, Match16) {
   URLPattern pattern(kAllSchemes);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("file://localhost/foo*"));
   EXPECT_EQ("file", pattern.scheme());
   // Since hostname is ignored for file://.
   EXPECT_EQ("", pattern.host());
   EXPECT_FALSE(pattern.match_subdomains());
+  EXPECT_TRUE(pattern.match_effective_tld());
   EXPECT_FALSE(pattern.match_all_urls());
   EXPECT_EQ("/foo*", pattern.path());
   EXPECT_FALSE(pattern.MatchesURL(GURL("file://foo")));
   EXPECT_FALSE(pattern.MatchesURL(GURL("file://foobar")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("file:///foo")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("file:///foobar")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("file://localhost/foo")));
 }
 
 // Specific port
@@ skipping 47 matching lines @@
   EXPECT_TRUE(pattern.MatchesURL(GURL("chrome-extension://ftw")));
   EXPECT_TRUE(pattern.MatchesURL(
       GURL("chrome-extension://ftw/http://google.com")));
   EXPECT_TRUE(pattern.MatchesURL(
       GURL("chrome-extension://ftw/https://google.com")));
   EXPECT_FALSE(pattern.MatchesURL(GURL("chrome-extension://foobar")));
   EXPECT_TRUE(pattern.MatchesURL(
       GURL("filesystem:chrome-extension://ftw/t/file.txt")));
 }
 
+// effective TLD wildcard
+TEST(URLPatternTest, EffectiveTldWildcard) {
+  URLPattern pattern(kAllSchemes);
+  EXPECT_EQ(URLPattern::PARSE_SUCCESS,
+            pattern.Parse("http://*.google.*/foo*bar",
+                          URLPattern::ALLOW_WILDCARD_FOR_EFFECTIVE_TLD));
+  EXPECT_EQ("http", pattern.scheme());
+  EXPECT_EQ("google", pattern.host());
+  EXPECT_TRUE(pattern.match_subdomains());
+  EXPECT_FALSE(pattern.match_effective_tld());
+  EXPECT_FALSE(pattern.match_all_urls());
+  EXPECT_EQ("/foo*bar", pattern.path());
+  EXPECT_TRUE(pattern.MatchesURL(GURL("http://google.com/foobar")));
+  EXPECT_TRUE(pattern.MatchesURL(GURL("http://www.google.com.br/foo?bar")));
+  EXPECT_TRUE(
+      pattern.MatchesURL(GURL("http://monkey.images.google.co.uk/foooobar")));
+  EXPECT_FALSE(pattern.MatchesURL(GURL("http://yahoo.com/foobar")));
+  EXPECT_TRUE(pattern.MatchesURL(GURL("filesystem:http://google.com/foo/bar")));
+  EXPECT_FALSE(pattern.MatchesURL(
+      GURL("filesystem:http://google.com/temporary/foobar")));
+  URLPattern pattern_sub(kAllSchemes);
+  EXPECT_EQ(URLPattern::PARSE_SUCCESS,
+            pattern_sub.Parse("https://maps.google.*/",
+                              URLPattern::ALLOW_WILDCARD_FOR_EFFECTIVE_TLD));
+  EXPECT_EQ("https", pattern_sub.scheme());
+  EXPECT_EQ("maps.google", pattern_sub.host());
+  EXPECT_FALSE(pattern_sub.match_subdomains());
+  EXPECT_FALSE(pattern_sub.match_all_urls());
+  EXPECT_EQ("/", pattern_sub.path());
+  EXPECT_TRUE(pattern_sub.MatchesURL(GURL("https://maps.google.co.uk/")));
+  EXPECT_FALSE(pattern_sub.MatchesURL(GURL("https://sub.maps.google.co.uk/")));
+}
+
 static const struct GetAsStringPatterns {
   const char* pattern;
 } kGetAsStringTestCases[] = {
   { "http://www/" },
   { "http://*/*" },
   { "chrome://*/*" },
   { "chrome://newtab/" },
   { "about:*" },
   { "about:blank" },
   { "chrome-extension://*/*" },
@@ skipping 426 matching lines @@
   EXPECT_TRUE(pattern.MatchesURL(normal_domain));
   EXPECT_TRUE(pattern.MatchesURL(trailing_dot_domain));
 
   const URLPattern trailing_pattern(URLPattern::SCHEME_HTTP,
                                     "*://example.com./*");
   EXPECT_TRUE(trailing_pattern.MatchesURL(normal_domain));
   EXPECT_TRUE(trailing_pattern.MatchesURL(trailing_dot_domain));
 }
 
 }  // namespace