Allow content script insertion on about:-URLs.

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 "base/memory/scoped_ptr.h"
 #include "extensions/common/url_pattern.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace {
 
 // See url_pattern.h for examples of valid and invalid patterns.
 
 static const int kAllSchemes =
     URLPattern::SCHEME_HTTP |
     URLPattern::SCHEME_HTTPS |
     URLPattern::SCHEME_FILE |
     URLPattern::SCHEME_FTP |
     URLPattern::SCHEME_CHROMEUI |
     URLPattern::SCHEME_EXTENSION |
-    URLPattern::SCHEME_FILESYSTEM;
+    URLPattern::SCHEME_FILESYSTEM|
+    URLPattern::SCHEME_ABOUT;
 
 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 },
@@ skipping 197 matching lines @@
 // <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.MatchesScheme("about"));
   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")));
+  EXPECT_TRUE(pattern.MatchesURL(GURL("about:blank")));
 
   // Make sure the properties are the same when creating an <all_urls> pattern
   // via SetMatchAllURLs and by parsing <all_urls>.
   URLPattern pattern2(kAllSchemes);
   pattern2.SetMatchAllURLs(true);
 
   EXPECT_EQ(pattern.valid_schemes(), pattern2.valid_schemes());
   EXPECT_EQ(pattern.match_subdomains(), pattern2.match_subdomains());
   EXPECT_EQ(pattern.path(), pattern2.path());
   EXPECT_EQ(pattern.match_all_urls(), pattern2.match_all_urls());
@@ skipping 159 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")));
 };
 
+// about:
+TEST(ExtensionURLPatternTest, Match20) {
+  URLPattern pattern(URLPattern::SCHEME_ABOUT);
+  EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("about:blank"));
+  EXPECT_EQ("about", pattern.scheme());
+  EXPECT_EQ("", pattern.host());
+  EXPECT_FALSE(pattern.match_subdomains());
+  EXPECT_FALSE(pattern.match_all_urls());
+  EXPECT_EQ("blank", pattern.path());
+  EXPECT_TRUE(pattern.MatchesURL(GURL("about:blank")));
+  EXPECT_FALSE(pattern.MatchesURL(GURL("about:srcdoc")));
+};
+
 static const struct GetAsStringPatterns {
   const char* pattern;
 } kGetAsStringTestCases[] = {
   { "http://www/" },
   { "http://*/*" },
   { "chrome://*/*" },
   { "chrome://newtab/" },
   { "about:*" },
   { "about:blank" },
   { "chrome-extension://*/*" },
@@ skipping 85 matching lines @@
 
   URLPatternList all_schemes(URLPattern(
       kAllSchemes,
       "*://google.com/foo").ConvertToExplicitSchemes());
 
   URLPatternList monkey(URLPattern(
       URLPattern::SCHEME_HTTP | URLPattern::SCHEME_HTTPS |
       URLPattern::SCHEME_FTP,
       "http://google.com/monkey").ConvertToExplicitSchemes());
 
-  ASSERT_EQ(7u, all_urls.size());
+  ASSERT_EQ(8u, all_urls.size());
   ASSERT_EQ(2u, all_schemes.size());
   ASSERT_EQ(1u, monkey.size());
 
   EXPECT_EQ("http://*/*", all_urls[0].GetAsString());
   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("about:/*", all_urls[7].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) {
   std::string pattern_str = "http://www.example.com:8080/foo";
   GURL url("http://www.example.com:1234/foo");
@@ skipping 245 matching lines @@
   EXPECT_TRUE(StrictlyContains(pattern10, pattern12));
   EXPECT_TRUE(StrictlyContains(pattern10, pattern13));
 
   // More...
   EXPECT_TRUE(StrictlyContains(pattern12, pattern11));
   EXPECT_TRUE(NeitherContains(pattern11, pattern13));
   EXPECT_TRUE(StrictlyContains(pattern12, pattern13));
 }
 
 }  // namespace