Allow URLPatterns to omit trailing slash.

Also, a regression had been introduced in earlier changes. Added explicit error codes to Parse(), and removed default constructor, to avoid making the same mistake again.

BUG=49969
TEST=n/a

Review URL: http://codereview.chromium.org/3978007

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@63836 0039d316-1c4b-4281-b951-d872f2087c98

11 files changed, 136 insertions, 70 deletions

diff --git a/chrome/browser/extensions/extension_context_menu_api.cc b/chrome/browser/extensions/extension_context_menu_api.cc
index 92e9ad4..51e9dfb 100644
--- a/chrome/browser/extensions/extension_context_menu_api.cc
+++ b/chrome/browser/extensions/extension_context_menu_api.cc
@@ -138,7 +138,7 @@ bool ExtensionContextMenuFunction::ParseURLPatterns(
       return false;
 
     URLPattern pattern(ExtensionMenuManager::kAllowedSchemes);
-    if (!pattern.Parse(tmp)) {
+    if (URLPattern::PARSE_SUCCESS != pattern.Parse(tmp)) {
       error_ = ExtensionErrorUtils::FormatErrorMessage(kInvalidURLPatternError,
                                                        tmp);
       return false;
diff --git a/chrome/browser/extensions/user_script_master.cc b/chrome/browser/extensions/user_script_master.cc
index 560fda3..6cb725d 100644
--- a/chrome/browser/extensions/user_script_master.cc
+++ b/chrome/browser/extensions/user_script_master.cc
@@ -108,7 +108,7 @@ bool UserScriptMaster::ScriptReloader::ParseMetadataHeader(
         script->set_description(value);
       } else if (GetDeclarationValue(line, kMatchDeclaration, &value)) {
         URLPattern pattern(UserScript::kValidUserScriptSchemes);
-        if (!pattern.Parse(value))
+        if (URLPattern::PARSE_SUCCESS != pattern.Parse(value))
           return false;
         script->add_url_pattern(pattern);
       } else if (GetDeclarationValue(line, kRunAtDeclaration, &value)) {
diff --git a/chrome/common/extensions/extension.cc b/chrome/common/extensions/extension.cc
index de50d07..74f6b22 100644
--- a/chrome/common/extensions/extension.cc
+++ b/chrome/common/extensions/extension.cc
@@ -534,12 +534,11 @@ bool Extension::LoadUserScriptHelper(const DictionaryValue* content_script,
       return false;
     }
 
-    URLPattern pattern;
+    URLPattern pattern(UserScript::kValidUserScriptSchemes);
     if (CanExecuteScriptEverywhere())
-      pattern = URLPattern(URLPattern::SCHEME_ALL);
-    else
-      pattern = URLPattern(UserScript::kValidUserScriptSchemes);
-    if (!pattern.Parse(match_str)) {
+      pattern.set_valid_schemes(URLPattern::SCHEME_ALL);
+
+    if (URLPattern::PARSE_SUCCESS != pattern.Parse(match_str)) {
       *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidMatch,
           base::IntToString(definition_index), base::IntToString(j));
       return false;
@@ -816,7 +815,12 @@ bool Extension::LoadExtent(const DictionaryValue* manifest,
     }
 
     URLPattern pattern(kValidWebExtentSchemes);
-    if (!pattern.Parse(pattern_string)) {
+    URLPattern::ParseResult result = pattern.Parse(pattern_string);
+    if (result == URLPattern::PARSE_ERROR_EMPTY_PATH) {
+      pattern_string += "/";
+      result = pattern.Parse(pattern_string);
+    }
+    if (URLPattern::PARSE_SUCCESS != result) {
       *error = ExtensionErrorUtils::FormatErrorMessage(value_error,
                                                        base::UintToString(i));
       return false;
@@ -1729,7 +1733,7 @@ bool Extension::InitFromValue(const DictionaryValue& source, bool require_key,
           (UserScript::kValidUserScriptSchemes |
               URLPattern::SCHEME_CHROMEUI) & ~URLPattern::SCHEME_FILE);
 
-      if (!pattern.Parse(permission_str)) {
+      if (URLPattern::PARSE_SUCCESS != pattern.Parse(permission_str)) {
         *error = ExtensionErrorUtils::FormatErrorMessage(
             errors::kInvalidPermission, base::IntToString(i));
         return false;
diff --git a/chrome/common/extensions/extension_manifests_unittest.cc b/chrome/common/extensions/extension_manifests_unittest.cc
index 5956dd1..e800cd9 100644
--- a/chrome/common/extensions/extension_manifests_unittest.cc
+++ b/chrome/common/extensions/extension_manifests_unittest.cc
@@ -361,3 +361,13 @@ TEST_F(ExtensionManifestTest, GetHomepageURL) {
   extension.reset(LoadAndExpectSuccess("homepage_externally_hosted.json"));
   EXPECT_EQ(GURL(), extension->GetHomepageURL());
 }
+
+TEST_F(ExtensionManifestTest, DefaultPathForExtent) {
+  scoped_ptr<Extension> extension(
+      LoadAndExpectSuccess("default_path_for_extent.json"));
+
+  ASSERT_EQ(1u, extension->web_extent().patterns().size());
+  EXPECT_EQ("/*", extension->web_extent().patterns()[0].path());
+  EXPECT_TRUE(extension->web_extent().ContainsURL(
+      GURL("http://www.google.com/monkey")));
+}
diff --git a/chrome/common/extensions/url_pattern.cc b/chrome/common/extensions/url_pattern.cc
index aa7e252..b6e09b7 100644
--- a/chrome/common/extensions/url_pattern.cc
+++ b/chrome/common/extensions/url_pattern.cc
@@ -58,14 +58,14 @@ URLPattern::URLPattern(int valid_schemes)
 URLPattern::URLPattern(int valid_schemes, const std::string& pattern)
     : valid_schemes_(valid_schemes), match_all_urls_(false),
       match_subdomains_(false) {
-  if (!Parse(pattern))
+  if (PARSE_SUCCESS != Parse(pattern))
     NOTREACHED() << "URLPattern is invalid: " << pattern;
 }
 
 URLPattern::~URLPattern() {
 }
 
-bool URLPattern::Parse(const std::string& pattern) {
+URLPattern::ParseResult URLPattern::Parse(const std::string& pattern) {
   // Special case pattern to match every valid URL.
   if (pattern == kAllUrlsPattern) {
     match_all_urls_ = true;
@@ -73,40 +73,51 @@ bool URLPattern::Parse(const std::string& pattern) {
     scheme_ = "*";
     host_.clear();
     path_ = "/*";
-    return true;
+    return PARSE_SUCCESS;
+  }
+
+  // Parse out the scheme.
+  size_t scheme_end_pos = pattern.find(chrome::kStandardSchemeSeparator);
+  bool has_standard_scheme_separator = true;
+
+  // Some urls also use ':' alone as the scheme separator.
+  if (scheme_end_pos == std::string::npos) {
+    scheme_end_pos = pattern.find(':');
+    has_standard_scheme_separator = false;
   }
 
-  size_t scheme_end_pos = pattern.find(":");
   if (scheme_end_pos == std::string::npos)
-    return false;
+    return PARSE_ERROR_MISSING_SCHEME_SEPARATOR;
 
   if (!SetScheme(pattern.substr(0, scheme_end_pos)))
-    return false;
+    return PARSE_ERROR_INVALID_SCHEME;
 
-  std::string separator =
-      pattern.substr(scheme_end_pos, strlen(chrome::kStandardSchemeSeparator));
-  if (separator == chrome::kStandardSchemeSeparator)
-    scheme_end_pos += strlen(chrome::kStandardSchemeSeparator);
-  else
-    scheme_end_pos += 1;
+  bool standard_scheme = IsStandardScheme(scheme_);
+  if (standard_scheme != has_standard_scheme_separator)
+    return PARSE_ERROR_WRONG_SCHEME_SEPARATOR;
 
   // Advance past the scheme separator.
-  size_t host_start_pos = scheme_end_pos;
-  if (host_start_pos >= pattern.length())
-    return false;
+  scheme_end_pos +=
+      (standard_scheme ? strlen(chrome::kStandardSchemeSeparator) : 1);
+  if (scheme_end_pos >= pattern.size())
+    return PARSE_ERROR_EMPTY_HOST;
 
   // Parse out the host and path.
+  size_t host_start_pos = scheme_end_pos;
   size_t path_start_pos = 0;
 
-  bool standard_scheme = IsStandardScheme(scheme_);
-
   // File URLs are special because they have no host.
   if (scheme_ == chrome::kFileScheme || !standard_scheme) {
     path_start_pos = host_start_pos;
   } else {
     size_t host_end_pos = pattern.find(kPathSeparator, host_start_pos);
+
+    // Host is required.
+    if (host_start_pos == host_end_pos)
+      return PARSE_ERROR_EMPTY_HOST;
+
     if (host_end_pos == std::string::npos)
-      return false;
+      return PARSE_ERROR_EMPTY_PATH;
 
     host_ = pattern.substr(host_start_pos, host_end_pos - host_start_pos);
 
@@ -124,14 +135,14 @@ bool URLPattern::Parse(const std::string& pattern) {
     // done as a convenience to developers who might otherwise be confused and
     // think '*' works as a glob in the host.
     if (host_.find('*') != std::string::npos)
-      return false;
+      return PARSE_ERROR_INVALID_HOST_WILDCARD;
 
     path_start_pos = host_end_pos;
   }
 
   path_ = pattern.substr(path_start_pos);
 
-  return true;
+  return PARSE_SUCCESS;
 }
 
 bool URLPattern::SetScheme(const std::string& scheme) {
diff --git a/chrome/common/extensions/url_pattern.h b/chrome/common/extensions/url_pattern.h
index 832673c..c0f17af 100644
--- a/chrome/common/extensions/url_pattern.h
+++ b/chrome/common/extensions/url_pattern.h
@@ -91,13 +91,20 @@ class URLPattern {
     SCHEME_ALL      = -1,
   };
 
+  // Error codes returned from Parse().
+  enum ParseResult {
+    PARSE_SUCCESS,
+    PARSE_ERROR_MISSING_SCHEME_SEPARATOR,
+    PARSE_ERROR_INVALID_SCHEME,
+    PARSE_ERROR_WRONG_SCHEME_SEPARATOR,
+    PARSE_ERROR_EMPTY_HOST,
+    PARSE_ERROR_INVALID_HOST_WILDCARD,
+    PARSE_ERROR_EMPTY_PATH,
+  };
+
   // The <all_urls> string pattern.
   static const char kAllUrlsPattern[];
 
-  // Note: don't use this directly. This exists so URLPattern can be used
-  // with STL containers.
-  URLPattern();
-
   // Construct an URLPattern with the given set of allowable schemes. See
   // valid_schemes_ for more info.
   explicit URLPattern(int valid_schemes);
@@ -134,9 +141,11 @@ class URLPattern {
   bool match_all_urls() const { return match_all_urls_; }
   void set_match_all_urls(bool val) { match_all_urls_ = val; }
 
-  // Initializes this instance by parsing the provided string. On failure, the
-  // instance will have some intermediate values and is in an invalid state.
-  bool Parse(const std::string& pattern_str);
+  // Initializes this instance by parsing the provided string. Returns
+  // URLPattern::PARSE_SUCCESS on success, or an error code otherwise. On
+  // failure, this instance will have some intermediate values and is in an
+  // invalid state.
+  ParseResult Parse(const std::string& pattern_str);
 
   // Sets the scheme for pattern matches. This can be a single '*' if the
   // pattern matches all valid schemes (as defined by the valid_schemes_
@@ -192,6 +201,12 @@ class URLPattern {
   };
 
  private:
+  friend class std::vector<URLPattern>;
+
+  // Note: don't use this directly. This exists so URLPattern can be used
+  // with STL containers.
+  URLPattern();
+
   // A bitmask containing the schemes which are considered valid for this
   // pattern. Parse() uses this to decide whether a pattern contains a valid
   // scheme. MatchesScheme uses this to decide whether a wildcard scheme_
diff --git a/chrome/common/extensions/url_pattern_unittest.cc b/chrome/common/extensions/url_pattern_unittest.cc
index a9ef21e..e0be087 100644
--- a/chrome/common/extensions/url_pattern_unittest.cc
+++ b/chrome/common/extensions/url_pattern_unittest.cc
@@ -17,29 +17,34 @@ static const int kAllSchemes =
     URLPattern::SCHEME_CHROMEUI;
 
 TEST(URLPatternTest, ParseInvalid) {
-  const char* kInvalidPatterns[] = {
-    "http",  // no scheme
-    "http:",
-    "http:/",
-    "http://",  // no path separator
-    "http://foo",  // no path separator
-    "http://*foo/bar",  // not allowed as substring of host component
-    "http://foo.*.bar/baz",  // must be first component
-    "http:/bar",  // scheme separator not found
-    "foo://*",  // invalid scheme
-    "chrome-extension://*/*",  // we don't support chrome extension URLs
+  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://*foo/bar", URLPattern::PARSE_ERROR_INVALID_HOST_WILDCARD },
+    { "http://foo.*.bar/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(kInvalidPatterns); ++i) {
-    URLPattern pattern;
-    EXPECT_FALSE(pattern.Parse(kInvalidPatterns[i])) << kInvalidPatterns[i];
+  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;
   }
 };
 
 // all pages for a given scheme
 TEST(URLPatternTest, Match1) {
   URLPattern pattern(kAllSchemes);
-  EXPECT_TRUE(pattern.Parse("http://*/*"));
+  EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("http://*/*"));
   EXPECT_EQ("http", pattern.scheme());
   EXPECT_EQ("", pattern.host());
   EXPECT_TRUE(pattern.match_subdomains());
@@ -55,7 +60,7 @@ TEST(URLPatternTest, Match1) {
 // all domains
 TEST(URLPatternTest, Match2) {
   URLPattern pattern(kAllSchemes);
-  EXPECT_TRUE(pattern.Parse("https://*/foo*"));
+  EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("https://*/foo*"));
   EXPECT_EQ("https", pattern.scheme());
   EXPECT_EQ("", pattern.host());
   EXPECT_TRUE(pattern.match_subdomains());
@@ -70,7 +75,8 @@ TEST(URLPatternTest, Match2) {
 // subdomains
 TEST(URLPatternTest, Match3) {
   URLPattern pattern(kAllSchemes);
-  EXPECT_TRUE(pattern.Parse("http://*.google.com/foo*bar"));
+  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());
@@ -86,7 +92,8 @@ TEST(URLPatternTest, Match3) {
 // glob escaping
 TEST(URLPatternTest, Match5) {
   URLPattern pattern(kAllSchemes);
-  EXPECT_TRUE(pattern.Parse("file:///foo?bar\\*baz"));
+  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());
@@ -99,7 +106,8 @@ TEST(URLPatternTest, Match5) {
 // ip addresses
 TEST(URLPatternTest, Match6) {
   URLPattern pattern(kAllSchemes);
-  EXPECT_TRUE(pattern.Parse("http://127.0.0.1/*"));
+  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());
@@ -111,7 +119,8 @@ TEST(URLPatternTest, Match6) {
 // subdomain matching with ip addresses
 TEST(URLPatternTest, Match7) {
   URLPattern pattern(kAllSchemes);
-  EXPECT_TRUE(pattern.Parse("http://*.0.0.1/*")); // allowed, but useless
+  EXPECT_EQ(URLPattern::PARSE_SUCCESS,
+            pattern.Parse("http://*.0.0.1/*")); // allowed, but useless
   EXPECT_EQ("http", pattern.scheme());
   EXPECT_EQ("0.0.1", pattern.host());
   EXPECT_TRUE(pattern.match_subdomains());
@@ -126,7 +135,8 @@ TEST(URLPatternTest, Match8) {
   URLPattern pattern(kAllSchemes);
   // The below is the ASCII encoding of the following URL:
   // http://*.\xe1\x80\xbf/a\xc2\x81\xe1*
-  EXPECT_TRUE(pattern.Parse("http://*.xn--gkd/a%C2%81%E1*"));
+  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());
@@ -141,7 +151,8 @@ TEST(URLPatternTest, Match8) {
 // chrome://
 TEST(URLPatternTest, Match9) {
   URLPattern pattern(kAllSchemes);
-  EXPECT_TRUE(pattern.Parse("chrome://favicon/*"));
+  EXPECT_EQ(URLPattern::PARSE_SUCCESS,
+            pattern.Parse("chrome://favicon/*"));
   EXPECT_EQ("chrome", pattern.scheme());
   EXPECT_EQ("favicon", pattern.host());
   EXPECT_FALSE(pattern.match_subdomains());
@@ -155,7 +166,7 @@ TEST(URLPatternTest, Match9) {
 // *://
 TEST(URLPatternTest, Match10) {
   URLPattern pattern(kAllSchemes);
-  EXPECT_TRUE(pattern.Parse("*://*/*"));
+  EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("*://*/*"));
   EXPECT_TRUE(pattern.MatchesScheme("http"));
   EXPECT_TRUE(pattern.MatchesScheme("https"));
   EXPECT_FALSE(pattern.MatchesScheme("chrome"));
@@ -172,7 +183,7 @@ TEST(URLPatternTest, Match10) {
 // <all_urls>
 TEST(URLPatternTest, Match11) {
   URLPattern pattern(kAllSchemes);
-  EXPECT_TRUE(pattern.Parse("<all_urls>"));
+  EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("<all_urls>"));
   EXPECT_TRUE(pattern.MatchesScheme("chrome"));
   EXPECT_TRUE(pattern.MatchesScheme("http"));
   EXPECT_TRUE(pattern.MatchesScheme("https"));
@@ -188,7 +199,7 @@ TEST(URLPatternTest, Match11) {
 // SCHEME_ALL matches all schemes.
 TEST(URLPatternTest, Match12) {
   URLPattern pattern(URLPattern::SCHEME_ALL);
-  EXPECT_TRUE(pattern.Parse("<all_urls>"));
+  EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("<all_urls>"));
   EXPECT_TRUE(pattern.MatchesScheme("chrome"));
   EXPECT_TRUE(pattern.MatchesScheme("http"));
   EXPECT_TRUE(pattern.MatchesScheme("https"));
@@ -226,7 +237,8 @@ static const struct MatchPatterns {
 TEST(URLPatternTest, Match13) {
   for (size_t i = 0; i < arraysize(kMatch13UrlPatternTestCases); ++i) {
     URLPattern pattern(URLPattern::SCHEME_ALL);
-    EXPECT_TRUE(pattern.Parse(kMatch13UrlPatternTestCases[i].pattern))
+    EXPECT_EQ(URLPattern::PARSE_SUCCESS,
+              pattern.Parse(kMatch13UrlPatternTestCases[i].pattern))
         << " while parsing " << kMatch13UrlPatternTestCases[i].pattern;
     EXPECT_TRUE(pattern.MatchesUrl(
         GURL(kMatch13UrlPatternTestCases[i].matches)))
@@ -235,7 +247,7 @@ TEST(URLPatternTest, Match13) {
 
   // Negative test.
   URLPattern pattern(URLPattern::SCHEME_ALL);
-  EXPECT_TRUE(pattern.Parse("data:*"));
+  EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("data:*"));
   EXPECT_FALSE(pattern.MatchesUrl(GURL("about:blank")));
 };
 
@@ -259,7 +271,8 @@ static const struct GetAsStringPatterns {
 TEST(URLPatternTest, GetAsString) {
   for (size_t i = 0; i < arraysize(kGetAsStringTestCases); ++i) {
     URLPattern pattern(URLPattern::SCHEME_ALL);
-    EXPECT_TRUE(pattern.Parse(kGetAsStringTestCases[i].pattern));
+    EXPECT_EQ(URLPattern::PARSE_SUCCESS,
+              pattern.Parse(kGetAsStringTestCases[i].pattern));
     EXPECT_STREQ(kGetAsStringTestCases[i].pattern,
                  pattern.GetAsString().c_str());
   }
diff --git a/chrome/common/extensions/user_script.cc b/chrome/common/extensions/user_script.cc
index cea7cf6..f71de5c 100644
--- a/chrome/common/extensions/user_script.cc
+++ b/chrome/common/extensions/user_script.cc
@@ -195,7 +195,7 @@ void UserScript::Unpickle(const ::Pickle& pickle, void** iter) {
     std::string pattern_str;
     URLPattern pattern(valid_schemes);
     CHECK(pickle.ReadString(iter, &pattern_str));
-    CHECK(pattern.Parse(pattern_str));
+    CHECK(URLPattern::PARSE_SUCCESS == pattern.Parse(pattern_str));
     url_patterns_.push_back(pattern);
   }
 
diff --git a/chrome/common/extensions/user_script_unittest.cc b/chrome/common/extensions/user_script_unittest.cc
index ab3e218..949ad1a 100644
--- a/chrome/common/extensions/user_script_unittest.cc
+++ b/chrome/common/extensions/user_script_unittest.cc
@@ -71,7 +71,7 @@ TEST(UserScriptTest, Match5) {
 
 TEST(UserScriptTest, Match6) {
   URLPattern pattern(kAllSchemes);
-  ASSERT_TRUE(pattern.Parse("http://*/foo*"));
+  ASSERT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("http://*/foo*"));
 
   UserScript script;
   script.add_url_pattern(pattern);
@@ -86,7 +86,8 @@ TEST(UserScriptTest, UrlPatternGlobInteraction) {
   UserScript script;
 
   URLPattern pattern(kAllSchemes);
-  ASSERT_TRUE(pattern.Parse("http://www.google.com/*"));
+  ASSERT_EQ(URLPattern::PARSE_SUCCESS,
+            pattern.Parse("http://www.google.com/*"));
   script.add_url_pattern(pattern);
 
   script.add_glob("*bar*");
@@ -114,8 +115,8 @@ TEST(UserScriptTest, UrlPatternGlobInteraction) {
 TEST(UserScriptTest, Pickle) {
   URLPattern pattern1(kAllSchemes);
   URLPattern pattern2(kAllSchemes);
-  ASSERT_TRUE(pattern1.Parse("http://*/foo*"));
-  ASSERT_TRUE(pattern2.Parse("http://bar/baz*"));
+  ASSERT_EQ(URLPattern::PARSE_SUCCESS, pattern1.Parse("http://*/foo*"));
+  ASSERT_EQ(URLPattern::PARSE_SUCCESS, pattern2.Parse("http://bar/baz*"));
 
   UserScript script1;
   script1.js_scripts().push_back(UserScript::File(
diff --git a/chrome/common/render_messages.cc b/chrome/common/render_messages.cc
index f437bf4..6442b29 100644
--- a/chrome/common/render_messages.cc
+++ b/chrome/common/render_messages.cc
@@ -863,7 +863,7 @@ bool ParamTraits<URLPattern>::Read(const Message* m, void** iter,
     return false;
 
   p->set_valid_schemes(valid_schemes);
-  return p->Parse(spec);
+  return URLPattern::PARSE_SUCCESS == p->Parse(spec);
 }
 
 void ParamTraits<URLPattern>::Log(const param_type& p, std::string* l) {
diff --git a/chrome/test/data/extensions/manifest_tests/default_path_for_extent.json b/chrome/test/data/extensions/manifest_tests/default_path_for_extent.json
new file mode 100644
index 0000000..4ea08d8
--- /dev/null
+++ b/chrome/test/data/extensions/manifest_tests/default_path_for_extent.json
@@ -0,0 +1,12 @@
+{
+  "name": "test",
+  "version": "1",
+  "app": {
+    "urls": [
+      "http://www.google.com"
+    ],
+    "launch": {
+      "web_url": "http://www.google.com/mail/"
+    }
+  }
+}