Add full support for filesystem URLs.

chrome/common/extensions/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 "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 16 matching lines @@
     { "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://*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:filesystem://bar", URLPattern::PARSE_ERROR_WRONG_SCHEME_SEPARATOR },
+    { "filesystem://bar", URLPattern::PARSE_ERROR_MISSING_SCHEME_SEPARATOR },
+    { "filesystem:filesystem:///bar", URLPattern::PARSE_ERROR_INVALID_SCHEME },
   };
 
   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))
         << kInvalidPatterns[i].pattern;
   }
 };
 
 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, "*" },
+    { "filesystem:http://foo:1234/", URLPattern::PARSE_SUCCESS, "1234" },
 
     // 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,"*" },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestPatterns); ++i) {
     URLPattern pattern(URLPattern::SCHEME_ALL);
     EXPECT_EQ(kTestPatterns[i].expected_result,
@@ skipping 12 matching lines @@
   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")));
+  EXPECT_FALSE(pattern.MatchesURL(GURL("filesystem:http://google.com")));
 }
 
 // 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_FALSE(pattern.match_all_urls());
   EXPECT_EQ("/foo*", pattern.path());
   EXPECT_TRUE(pattern.MatchesURL(GURL("https://www.google.com/foo")));
+  EXPECT_FALSE(
+      pattern.MatchesURL(GURL("filesystem: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"));
@@ skipping 82 matching lines @@
 
 // *://
 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_FALSE(pattern.MatchesScheme("filesystem"));
   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>"));
   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_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("filesystem:file:///temporary/foo/bar")));
+  EXPECT_TRUE(pattern.MatchesURL(
+      GURL("filesystem:http://google.com/temporary/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);
   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());
   EXPECT_EQ(pattern.scheme(), pattern2.scheme());
   EXPECT_EQ(pattern.port(), pattern2.port());
   EXPECT_EQ(pattern.GetAsString(), pattern2.GetAsString());
 };
 
 // SCHEME_ALL matches all schemes.
 TEST(ExtensionURLPatternTest, Match12) {
   URLPattern pattern(URLPattern::SCHEME_ALL);
   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("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());
   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("filesystem:file:///persistent/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(
       GURL("data:text/html;charset=utf-8,<html>asdf</html>")));
 };
 
 static const struct MatchPatterns {
   const char* pattern;
   const char* matches;
 } kMatch13UrlPatternTestCases[] = {
   {"about:*", "about:blank"},
   {"about:blank", "about:blank"},
   {"about:*", "about:version"},
   {"chrome-extension://*/*", "chrome-extension://FTW"},
   {"data:*", "data:monkey"},
+  {"filesystem:http://*/*", "filesystem:http://monkey.com/t/f.txt"},
   {"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))
         << " while parsing " << kMatch13UrlPatternTestCases[i].pattern;
@@ skipping 100 matching lines @@
   EXPECT_FALSE(pattern.match_all_urls());
   EXPECT_EQ("/*", pattern.path());
   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")));
 };
 
+// filesystem:http://
+TEST(ExtensionURLPatternTest, Match20) {
+  URLPattern pattern(kAllSchemes);
+  EXPECT_EQ(URLPattern::PARSE_SUCCESS,
+      pattern.Parse("filesystem:http://foo.com/t/*"));
+  EXPECT_EQ("filesystem", pattern.scheme());
+  EXPECT_EQ("http", pattern.inner_scheme());
+  EXPECT_EQ("foo.com", pattern.host());
+  EXPECT_FALSE(pattern.match_subdomains());
+  EXPECT_FALSE(pattern.match_all_urls());
+  EXPECT_EQ("/t/*", pattern.path());
+  EXPECT_TRUE(pattern.MatchesURL(GURL("filesystem:http://foo.com/t/blah")));
+  EXPECT_TRUE(pattern.MatchesURL(GURL("filesystem:http://foo.com/t/bar")));
+  EXPECT_FALSE(pattern.MatchesURL(GURL("filesystem:https://foo.com/t/bar")));
+  EXPECT_FALSE(pattern.MatchesURL(GURL("filesystem:file://foo.com/t/bar")));
+  EXPECT_FALSE(pattern.MatchesURL(GURL("filesystem:http://bar.com/t/bar")));
+  EXPECT_FALSE(pattern.MatchesURL(GURL("filesystem:http://foo.com/p/bar")));
+  EXPECT_FALSE(pattern.MatchesURL(GURL("filesystem:http://foo.com/t")));
+};
+
+// filesystem:chrome-extension://
+TEST(ExtensionURLPatternTest, Match22) {
+  URLPattern pattern(kAllSchemes);
+  EXPECT_EQ(URLPattern::PARSE_SUCCESS,
+      pattern.Parse("filesystem:chrome-extension://*/*.txt"));
+  EXPECT_EQ("filesystem", pattern.scheme());
+  EXPECT_EQ("chrome-extension", pattern.inner_scheme());
+  EXPECT_EQ("", pattern.host());
+  EXPECT_TRUE(pattern.match_subdomains());
+  EXPECT_FALSE(pattern.match_all_urls());
+  EXPECT_EQ("/*.txt", pattern.path());
+  EXPECT_FALSE(pattern.MatchesURL(
+      GURL("filesystem:chrome-extension://39804298/t/blah")));
+  // This is FALSE because 't' becomes the host [the extension id], which makes
+  // 'bar.txt' the storage specifier of the filesystem URL, so there's no path
+  // left.
+  EXPECT_FALSE(pattern.MatchesURL(
+      GURL("filesystem:chrome-extension://t/bar.txt")));
+  EXPECT_TRUE(pattern.MatchesURL(
+      GURL("filesystem:chrome-extension://t/t/bar.txt")));
+};
+
 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:8080/foo" },
+  { "filesystem:http://www.example.com:8080/foo" },
+  { "filesystem:file:///foo" },
+  { "filesystem:*://foo/bar" },
+  { "file:///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))
         << "Error parsing " << kGetAsStringTestCases[i].pattern;
     EXPECT_EQ(kGetAsStringTestCases[i].pattern,
               pattern.GetAsString());
@@ skipping 164 matching lines @@
     },
 
     // all_urls
     { "<all_urls>",
       "<all_urls>",
       true
     },
     { "<all_urls>",
       "http://*/*",
       false
+    },
+
+    // filesystem inner_schemes
+    { "filesystem:file://foo/*",
+      "filesystem:file://foo/*",
+      true
+    },
+    { "filesystem:http://foo/*",
+      "filesystem:file://foo/*",
+      false
     }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kEqualsTestCases); ++i) {
     std::string message = kEqualsTestCases[i].pattern1;
     message += " ";
     message += kEqualsTestCases[i].pattern2;
 
     URLPattern pattern1(URLPattern::SCHEME_ALL);
     URLPattern pattern2(URLPattern::SCHEME_ALL);
 
     pattern1.Parse(kEqualsTestCases[i].pattern1);
     pattern2.Parse(kEqualsTestCases[i].pattern2);
     EXPECT_EQ(kEqualsTestCases[i].expected_equal, pattern1 == pattern2)
         << message;
   }
 }
-
-TEST(ExtensionURLPatternTest, CanReusePatternWithParse) {

[ericu, 2012/02/23 01:39:13]

This looks like a merge botch; I'll put it back.

-  URLPattern pattern1(URLPattern::SCHEME_ALL);
-  EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern1.Parse("http://aa.com/*"));
-  EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern1.Parse("http://bb.com/*"));
-
-  EXPECT_TRUE(pattern1.MatchesURL(GURL("http://bb.com/path")));
-  EXPECT_FALSE(pattern1.MatchesURL(GURL("http://aa.com/path")));
-
-  URLPattern pattern2(URLPattern::SCHEME_ALL, URLPattern::kAllUrlsPattern);
-  EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern2.Parse("http://aa.com/*"));
-
-  EXPECT_FALSE(pattern2.MatchesURL(GURL("http://bb.com/path")));
-  EXPECT_TRUE(pattern2.MatchesURL(GURL("http://aa.com/path")));
-  EXPECT_FALSE(pattern2.MatchesURL(GURL("http://sub.aa.com/path")));
-
-  URLPattern pattern3(URLPattern::SCHEME_ALL, "http://aa.com/*");
-  EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern3.Parse("http://aa.com:88/*"));
-  EXPECT_FALSE(pattern3.MatchesURL(GURL("http://aa.com/path")));
-  EXPECT_TRUE(pattern3.MatchesURL(GURL("http://aa.com:88/path")));
-}