Implement "scope" Web Manifest parsing

content/renderer/manifest/manifest_parser.cc

 // Copyright 2014 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 "content/renderer/manifest/manifest_parser.h"
 
 #include <stddef.h>
 
 #include "base/json/json_reader.h"
 #include "base/memory/ptr_util.h"
@@ skipping 46 matching lines @@
     AddErrorInfo("root element must be a valid JSON object.", true);
     ManifestUmaUtil::ParseFailed();
     failed_ = true;
     return;
   }
   DCHECK(dictionary);
 
   manifest_.name = ParseName(*dictionary);
   manifest_.short_name = ParseShortName(*dictionary);
   manifest_.start_url = ParseStartURL(*dictionary);
+  manifest_.scope = ParseScope(*dictionary, manifest_.start_url);
   manifest_.display = ParseDisplay(*dictionary);
   manifest_.orientation = ParseOrientation(*dictionary);
   manifest_.icons = ParseIcons(*dictionary);
   manifest_.related_applications = ParseRelatedApplications(*dictionary);
   manifest_.prefer_related_applications =
       ParsePreferRelatedApplications(*dictionary);
   manifest_.theme_color = ParseThemeColor(*dictionary);
   manifest_.background_color = ParseBackgroundColor(*dictionary);
   manifest_.gcm_sender_id = ParseGCMSenderID(*dictionary);
 
@@ skipping 72 matching lines @@
   return static_cast<int64_t>(signed_color);
 }
 
 GURL ManifestParser::ParseURL(const base::DictionaryValue& dictionary,
                               const std::string& key,
                               const GURL& base_url) {
   base::NullableString16 url_str = ParseString(dictionary, key, NoTrim);
   if (url_str.is_null())
     return GURL();
 
-  return base_url.Resolve(url_str.string());
+  GURL resolved = base_url.Resolve(url_str.string());
+  if (!resolved.is_valid())
+    AddErrorInfo("property '" + key + "' ignored, URL is invalid.");
+  return resolved;
 }
 
 base::NullableString16 ManifestParser::ParseName(
     const base::DictionaryValue& dictionary)  {
   return ParseString(dictionary, "name", Trim);
 }
 
 base::NullableString16 ManifestParser::ParseShortName(
     const base::DictionaryValue& dictionary)  {
   return ParseString(dictionary, "short_name", Trim);
 }
 
 GURL ManifestParser::ParseStartURL(const base::DictionaryValue& dictionary) {
   GURL start_url = ParseURL(dictionary, "start_url", manifest_url_);
   if (!start_url.is_valid())
     return GURL();
 
   if (start_url.GetOrigin() != document_url_.GetOrigin()) {
     AddErrorInfo("property 'start_url' ignored, should be "
                  "same origin as document.");
     return GURL();
   }
 
   return start_url;
 }
 
+GURL ManifestParser::ParseScope(const base::DictionaryValue& dictionary,
+                                const GURL& start_url) {
+  GURL scope = ParseURL(dictionary, "scope", manifest_url_);
+  if (!scope.is_valid()) {
+    return GURL();
+  }
+
+  if (scope.GetOrigin() != document_url_.GetOrigin()) {
+    AddErrorInfo("property 'scope' ignored, should be "
+                 "same origin as document.");
+    return GURL();
+  }
+
+  // According to the spec, if the start_url cannot be parsed, the document URL
+  // should be used as the start URL. If the start_url could not be parsed,
+  // check that the document URL is within scope.
+  GURL check_in_scope = start_url.is_empty() ? document_url_ : start_url;
+  if (check_in_scope.GetOrigin() != scope.GetOrigin() ||
+      !base::StartsWith(check_in_scope.path(), scope.path(),
+                        base::CompareCase::SENSITIVE)) {
+    AddErrorInfo(
+        "property 'scope' ignored. Start url should be within scope "
+        "of scope URL.");
+    return GURL();
+  }
+  return scope;
+}
+
 blink::WebDisplayMode ManifestParser::ParseDisplay(
     const base::DictionaryValue& dictionary) {
   base::NullableString16 display = ParseString(dictionary, "display", Trim);
   if (display.is_null())
     return blink::WebDisplayModeUndefined;
 
   if (base::LowerCaseEqualsASCII(display.string(), "fullscreen"))
     return blink::WebDisplayModeFullscreen;
   else if (base::LowerCaseEqualsASCII(display.string(), "standalone"))
     return blink::WebDisplayModeStandalone;
@@ skipping 181 matching lines @@
 }
 
 void ManifestParser::AddErrorInfo(const std::string& error_msg,
                                   bool critical,
                                   int error_line,
                                   int error_column) {
   errors_.push_back({error_msg, critical, error_line, error_column});
 }
 
 } // namespace content