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 25 matching lines @@
 
   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))
         << kInvalidPatterns[i].pattern;
   }
 };
 
-TEST(ExtensionURLPatternTest, Colons) {
+TEST(ExtensionURLPatternTest, Ports) {
   const struct {
     const char* pattern;
-    URLPattern::ParseResult expected_result;
+    URLPattern::ParseResult expected_result_strict;
+    URLPattern::ParseResult expected_result_lenient;
+    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);
 
-    // Without |strict_error_checks|, expect success.
-    EXPECT_EQ(URLPattern::PARSE_SUCCESS,
+    // Check results without |strict_error_checks|.
+    EXPECT_EQ(kTestPatterns[i].expected_result_lenient,
               pattern.Parse(kTestPatterns[i].pattern,
                             URLPattern::PARSE_LENIENT))
-        << "Got unexpected error for URL pattern: "
+        << "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;
 
-    EXPECT_EQ(kTestPatterns[i].expected_result,
+    // Check results with |strict_error_checks|.
+    EXPECT_EQ(kTestPatterns[i].expected_result_strict,
               pattern.Parse(kTestPatterns[i].pattern,
                             URLPattern::PARSE_STRICT))
         << "Got unexpected result for URL pattern: "
         << kTestPatterns[i].pattern;
   }
 };
 
 // all pages for a given scheme
 TEST(ExtensionURLPatternTest, Match1) {
   URLPattern pattern(kAllSchemes);
@@ skipping 277 matching lines @@
   { "chrome://*/*" },
   { "chrome://newtab/" },
   { "about:*" },
   { "about:blank" },
   { "chrome-extension://*/*" },
   { "chrome-extension://FTW/" },
   { "data:*" },
   { "data:monkey" },
   { "javascript:*" },
   { "javascript:atemyhomework" },
+  { "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));
+                            URLPattern::PARSE_LENIENT));
     EXPECT_STREQ(kGetAsStringTestCases[i].pattern,
                  pattern.GetAsString().c_str());
   }
 }
 
 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))
@@ skipping 68 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::PARSE_LENIENT));
+
+  EXPECT_EQ("http://www.example.com/foo", pattern1.GetAsString());
+  EXPECT_TRUE(pattern1.MatchesURL(GURL("http://www.example.com:1234/foo")));
+
+  URLPattern pattern2(kAllSchemes);
+  pattern2.set_ignores_ports(false);
+  EXPECT_EQ(URLPattern::PARSE_SUCCESS,
+            pattern2.Parse("http://www.example.com:8080/foo",
+                           URLPattern::PARSE_LENIENT));
+
+  EXPECT_EQ("http://www.example.com:8080/foo", pattern2.GetAsString());
+  EXPECT_FALSE(pattern2.MatchesURL(GURL("http://www.example.com:1234/foo")));
+}