Use extension match pattern syntax in content settings extension API

chrome/common/extensions/url_pattern_unittest.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 "base/memory/scoped_ptr.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "googleurl/src/gurl.h"
 
 // See url_pattern.h for examples of valid and invalid patterns.
@@ skipping 20 matching lines @@
     { "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 },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kInvalidPatterns); ++i) {
     URLPattern pattern(URLPattern::SCHEME_ALL);
     EXPECT_EQ(kInvalidPatterns[i].expected_result,
               pattern.Parse(kInvalidPatterns[i].pattern,
-                            URLPattern::PARSE_LENIENT))
+                            URLPattern::IGNORE_PORTS))
         << kInvalidPatterns[i].pattern;
   }
 };
 
-TEST(ExtensionURLPatternTest, Colons) {
+TEST(ExtensionURLPatternTest, Ports) {
   const struct {
     const char* pattern;
-    URLPattern::ParseResult expected_result;
+    URLPattern::ParseResult expected_result_error_on_ports;
+    URLPattern::ParseResult expected_result_use_ports;
+    const char* expected_port;
   } kTestPatterns[] = {
-    { "http://foo:1234/", URLPattern::PARSE_ERROR_HAS_COLON },
-    { "http://foo:1234/bar", URLPattern::PARSE_ERROR_HAS_COLON },
-    { "http://*.foo:1234/", URLPattern::PARSE_ERROR_HAS_COLON },
-    { "http://*.foo:1234/bar", URLPattern::PARSE_ERROR_HAS_COLON },
-    { "http://:1234/", URLPattern::PARSE_ERROR_HAS_COLON },
-    { "http://foo:/", URLPattern::PARSE_ERROR_HAS_COLON },
-    { "http://*.foo:/", URLPattern::PARSE_ERROR_HAS_COLON },
-    { "http://foo:com/", URLPattern::PARSE_ERROR_HAS_COLON },
+    { "http://foo:1234/", URLPattern::PARSE_ERROR_HAS_COLON,
+      URLPattern::PARSE_SUCCESS, "1234" },
+    { "http://foo:1234/bar", URLPattern::PARSE_ERROR_HAS_COLON,
+      URLPattern::PARSE_SUCCESS, "1234" },
+    { "http://*.foo:1234/", URLPattern::PARSE_ERROR_HAS_COLON,
+      URLPattern::PARSE_SUCCESS, "1234" },
+    { "http://*.foo:1234/bar", URLPattern::PARSE_ERROR_HAS_COLON,
+      URLPattern::PARSE_SUCCESS, "1234" },
+    { "http://:1234/", URLPattern::PARSE_ERROR_HAS_COLON,
+      URLPattern::PARSE_SUCCESS, "1234" },
+    { "http://foo:/", URLPattern::PARSE_ERROR_HAS_COLON,
+      URLPattern::PARSE_SUCCESS, "" },
+    { "http://foo:*/", URLPattern::PARSE_ERROR_HAS_COLON,
+      URLPattern::PARSE_SUCCESS, "*" },
+    { "http://*.foo:/", URLPattern::PARSE_ERROR_HAS_COLON,
+      URLPattern::PARSE_SUCCESS, "" },
+    { "http://foo:com/", URLPattern::PARSE_ERROR_HAS_COLON,
+      URLPattern::PARSE_ERROR_INVALID_PORT, "*" },
+    { "http://foo:123456/", URLPattern::PARSE_ERROR_HAS_COLON,
+      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 },
+    { "http://*/:1234", URLPattern::PARSE_SUCCESS,
+      URLPattern::PARSE_SUCCESS, "*" },
+    { "http://*.foo/bar:1234", URLPattern::PARSE_SUCCESS,
+      URLPattern::PARSE_SUCCESS, "*" },
+    { "http://foo/bar:1234/path", URLPattern::PARSE_SUCCESS,
+      URLPattern::PARSE_SUCCESS, "*" },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestPatterns); ++i) {
-    URLPattern pattern(URLPattern::SCHEME_ALL);
+    URLPattern use_ports_pattern(URLPattern::SCHEME_ALL);
+    // Check results with |USE_PORTS|.
+    EXPECT_EQ(kTestPatterns[i].expected_result_use_ports,
+              use_ports_pattern.Parse(kTestPatterns[i].pattern,
+                                      URLPattern::USE_PORTS))
+        << "Got unexpected result for URL pattern: "
+        << kTestPatterns[i].pattern;
+    EXPECT_EQ(kTestPatterns[i].expected_port, use_ports_pattern.port())
+        << "Got unexpected port for URL pattern: " << kTestPatterns[i].pattern;
 
-    // Without |strict_error_checks|, expect success.
+    URLPattern ignore_ports_pattern(URLPattern::SCHEME_ALL);
+    // Check results with |IGNORE_PORTS|.
     EXPECT_EQ(URLPattern::PARSE_SUCCESS,
-              pattern.Parse(kTestPatterns[i].pattern,
-                            URLPattern::PARSE_LENIENT))
-        << "Got unexpected error for URL pattern: "
+              ignore_ports_pattern.Parse(kTestPatterns[i].pattern,
+                                         URLPattern::IGNORE_PORTS))
+        << "Got unexpected result for URL pattern: "
         << kTestPatterns[i].pattern;
+    EXPECT_EQ("*", ignore_ports_pattern.port())
+        << "Got unexpected port for URL pattern: " << kTestPatterns[i].pattern;
 
-    EXPECT_EQ(kTestPatterns[i].expected_result,
-              pattern.Parse(kTestPatterns[i].pattern,
-                            URLPattern::PARSE_STRICT))
+    URLPattern error_on_ports_pattern(URLPattern::SCHEME_ALL);
+    // Check results with |ERROR_ON_PORTS|.
+    EXPECT_EQ(kTestPatterns[i].expected_result_error_on_ports,
+              error_on_ports_pattern.Parse(kTestPatterns[i].pattern,
+                                           URLPattern::ERROR_ON_PORTS))
         << "Got unexpected result 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://*/*", URLPattern::PARSE_STRICT));
+            pattern.Parse("http://*/*", URLPattern::ERROR_ON_PORTS));
   EXPECT_EQ("http", pattern.scheme());
   EXPECT_EQ("", pattern.host());
   EXPECT_TRUE(pattern.match_subdomains());
   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*", URLPattern::PARSE_STRICT));
+            pattern.Parse("https://*/foo*", URLPattern::ERROR_ON_PORTS));
   EXPECT_EQ("https", pattern.scheme());
   EXPECT_EQ("", pattern.host());
   EXPECT_TRUE(pattern.match_subdomains());
   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/")));
 }
 
 // subdomains
 TEST(URLPatternTest, Match3) {
   URLPattern pattern(kAllSchemes);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS,
             pattern.Parse("http://*.google.com/foo*bar",
-                          URLPattern::PARSE_STRICT));
+                          URLPattern::ERROR_ON_PORTS));
   EXPECT_EQ("http", pattern.scheme());
   EXPECT_EQ("google.com", pattern.host());
   EXPECT_TRUE(pattern.match_subdomains());
   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")));
 }
 
 // glob escaping
 TEST(ExtensionURLPatternTest, Match5) {
   URLPattern pattern(kAllSchemes);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS,
-            pattern.Parse("file:///foo?bar\\*baz", URLPattern::PARSE_STRICT));
+            pattern.Parse("file:///foo?bar\\*baz", URLPattern::ERROR_ON_PORTS));
   EXPECT_EQ("file", pattern.scheme());
   EXPECT_EQ("", pattern.host());
   EXPECT_FALSE(pattern.match_subdomains());
   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/*", URLPattern::PARSE_STRICT));
+            pattern.Parse("http://127.0.0.1/*", URLPattern::ERROR_ON_PORTS));
   EXPECT_EQ("http", pattern.scheme());
   EXPECT_EQ("127.0.0.1", pattern.host());
   EXPECT_FALSE(pattern.match_subdomains());
   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);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS,
             pattern.Parse("http://*.0.0.1/*",
-                          URLPattern::PARSE_STRICT)); // allowed, but useless
+                          URLPattern::ERROR_ON_PORTS)); // allowed, but useless
   EXPECT_EQ("http", pattern.scheme());
   EXPECT_EQ("0.0.1", pattern.host());
   EXPECT_TRUE(pattern.match_subdomains());
   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*",
-                          URLPattern::PARSE_STRICT));
+                          URLPattern::ERROR_ON_PORTS));
   EXPECT_EQ("http", pattern.scheme());
   EXPECT_EQ("xn--gkd", pattern.host());
   EXPECT_TRUE(pattern.match_subdomains());
   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/*", URLPattern::PARSE_STRICT));
+            pattern.Parse("chrome://favicon/*", URLPattern::ERROR_ON_PORTS));
   EXPECT_EQ("chrome", pattern.scheme());
   EXPECT_EQ("favicon", pattern.host());
   EXPECT_FALSE(pattern.match_subdomains());
   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("*://*/*", URLPattern::PARSE_STRICT));
+            pattern.Parse("*://*/*", URLPattern::ERROR_ON_PORTS));
   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_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>", URLPattern::PARSE_STRICT));
+            pattern.Parse("<all_urls>", URLPattern::ERROR_ON_PORTS));
   EXPECT_TRUE(pattern.MatchesScheme("chrome"));
   EXPECT_TRUE(pattern.MatchesScheme("http"));
   EXPECT_TRUE(pattern.MatchesScheme("https"));
   EXPECT_TRUE(pattern.MatchesScheme("file"));
   EXPECT_TRUE(pattern.match_subdomains());
   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")));
 };
 
 // SCHEME_ALL matches all schemes.
 TEST(ExtensionURLPatternTest, Match12) {
   URLPattern pattern(URLPattern::SCHEME_ALL);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS,
-            pattern.Parse("<all_urls>", URLPattern::PARSE_STRICT));
+            pattern.Parse("<all_urls>", URLPattern::ERROR_ON_PORTS));
   EXPECT_TRUE(pattern.MatchesScheme("chrome"));
   EXPECT_TRUE(pattern.MatchesScheme("http"));
   EXPECT_TRUE(pattern.MatchesScheme("https"));
   EXPECT_TRUE(pattern.MatchesScheme("file"));
   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_all_urls());
@@ skipping 20 matching lines @@
   {"data:*", "data:monkey"},
   {"javascript:*", "javascript:atemyhomework"},
 };
 
 // SCHEME_ALL and specific schemes.
 TEST(ExtensionURLPatternTest, Match13) {
   for (size_t i = 0; i < arraysize(kMatch13UrlPatternTestCases); ++i) {
     URLPattern pattern(URLPattern::SCHEME_ALL);
     EXPECT_EQ(URLPattern::PARSE_SUCCESS,
               pattern.Parse(kMatch13UrlPatternTestCases[i].pattern,
-                            URLPattern::PARSE_STRICT))
+                            URLPattern::ERROR_ON_PORTS))
         << " while parsing " << kMatch13UrlPatternTestCases[i].pattern;
     EXPECT_TRUE(pattern.MatchesURL(
         GURL(kMatch13UrlPatternTestCases[i].matches)))
         << " while matching " << kMatch13UrlPatternTestCases[i].matches;
   }
 
   // Negative test.
   URLPattern pattern(URLPattern::SCHEME_ALL);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS,
-            pattern.Parse("data:*", URLPattern::PARSE_STRICT));
+            pattern.Parse("data:*", URLPattern::ERROR_ON_PORTS));
   EXPECT_FALSE(pattern.MatchesURL(GURL("about:blank")));
 };
 
 // file scheme with empty hostname
 TEST(ExtensionURLPatternTest, Match14) {
   URLPattern pattern(kAllSchemes);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS,
-            pattern.Parse("file:///foo*", URLPattern::PARSE_STRICT));
+            pattern.Parse("file:///foo*", URLPattern::ERROR_ON_PORTS));
   EXPECT_EQ("file", pattern.scheme());
   EXPECT_EQ("", pattern.host());
   EXPECT_FALSE(pattern.match_subdomains());
   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")));
 }
 
 // file scheme without hostname part
 TEST(ExtensionURLPatternTest, Match15) {
   URLPattern pattern(kAllSchemes);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS,
-            pattern.Parse("file://foo*", URLPattern::PARSE_STRICT));
+            pattern.Parse("file://foo*", URLPattern::ERROR_ON_PORTS));
   EXPECT_EQ("file", pattern.scheme());
   EXPECT_EQ("", pattern.host());
   EXPECT_FALSE(pattern.match_subdomains());
   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")));
 }
 
 // file scheme with hostname
 TEST(ExtensionURLPatternTest, Match16) {
   URLPattern pattern(kAllSchemes);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS,
-            pattern.Parse("file://localhost/foo*", URLPattern::PARSE_STRICT));
+            pattern.Parse("file://localhost/foo*", URLPattern::ERROR_ON_PORTS));
   EXPECT_EQ("file", pattern.scheme());
   // Since hostname is ignored for file://.
   EXPECT_EQ("", pattern.host());
   EXPECT_FALSE(pattern.match_subdomains());
   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")));
 }
 
 static const struct GetAsStringPatterns {
   const char* pattern;
 } kGetAsStringTestCases[] = {
   { "http://www/" },
   { "http://*/*" },
   { "chrome://*/*" },
   { "chrome://newtab/" },
   { "about:*" },
   { "about:blank" },
   { "chrome-extension://*/*" },
   { "chrome-extension://FTW/" },
   { "data:*" },
   { "data:monkey" },
   { "javascript:*" },
   { "javascript:atemyhomework" },
+  { "http://www.example.com:/foo" },
+  { "http://www.example.com:8080/foo" },
 };
 
 TEST(ExtensionURLPatternTest, GetAsString) {
   for (size_t i = 0; i < arraysize(kGetAsStringTestCases); ++i) {
     URLPattern pattern(URLPattern::SCHEME_ALL);
     EXPECT_EQ(URLPattern::PARSE_SUCCESS,
               pattern.Parse(kGetAsStringTestCases[i].pattern,
-                            URLPattern::PARSE_STRICT));
-    EXPECT_STREQ(kGetAsStringTestCases[i].pattern,
-                 pattern.GetAsString().c_str());
+                            URLPattern::USE_PORTS));
+    EXPECT_EQ(kGetAsStringTestCases[i].pattern,
+              pattern.GetAsString());
   }
 }
 
 void TestPatternOverlap(const URLPattern& pattern1, const URLPattern& pattern2,
                         bool expect_overlap) {
   EXPECT_EQ(expect_overlap, pattern1.OverlapsWith(pattern2))
       << pattern1.GetAsString() << ", " << pattern2.GetAsString();
   EXPECT_EQ(expect_overlap, pattern2.OverlapsWith(pattern1))
       << pattern2.GetAsString() << ", " << pattern1.GetAsString();
 }
@@ skipping 66 matching lines @@
   EXPECT_EQ("https://*/*", all_urls[1].GetAsString());
   EXPECT_EQ("file:///*", all_urls[2].GetAsString());
   EXPECT_EQ("ftp://*/*", all_urls[3].GetAsString());
   EXPECT_EQ("chrome://*/*", all_urls[4].GetAsString());
 
   EXPECT_EQ("http://google.com/foo", all_schemes[0].GetAsString());
   EXPECT_EQ("https://google.com/foo", all_schemes[1].GetAsString());
 
   EXPECT_EQ("http://google.com/monkey", monkey[0].GetAsString());
 }
+
+TEST(ExtensionURLPatternTest, IgnorePorts) {
+  URLPattern pattern1(kAllSchemes);
+  EXPECT_EQ(URLPattern::PARSE_SUCCESS,
+            pattern1.Parse("http://www.example.com:8080/foo",
+                           URLPattern::IGNORE_PORTS));
+
+  EXPECT_EQ("http://www.example.com/foo", pattern1.GetAsString());
+  EXPECT_TRUE(pattern1.MatchesURL(GURL("http://www.example.com:1234/foo")));
+
+  URLPattern pattern2(kAllSchemes);
+  EXPECT_EQ(URLPattern::PARSE_SUCCESS,
+            pattern2.Parse("http://www.example.com:8080/foo",
+                           URLPattern::USE_PORTS));
+
+  EXPECT_EQ("http://www.example.com:8080/foo", pattern2.GetAsString());
+  EXPECT_FALSE(pattern2.MatchesURL(GURL("http://www.example.com:1234/foo")));

[Sam Kerner (Chrome), 2011/06/28 18:12:39]

Consider testing a pattern with a * as the port.

+}