Pass Manifest JSON paser error line and column number to console.

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/strings/nullable_string16.h"
@@ skipping 87 matching lines @@
     : data_(data),
       manifest_url_(manifest_url),
       document_url_(document_url),
       failed_(false) {
 }
 
 ManifestParser::~ManifestParser() {
 }
 
 void ManifestParser::Parse() {
-  std::string parse_error;
+  std::string error_msg;
+  int error_line = 0;
+  int error_column = 0;
   scoped_ptr<base::Value> value = base::JSONReader::ReadAndReturnError(
-      data_, base::JSON_PARSE_RFC, nullptr, &parse_error);
+      data_, base::JSON_PARSE_RFC, nullptr, &error_msg, &error_line,
+      &error_column);
 
   if (!value) {
-    errors_.push_back(GetErrorPrefix() + parse_error);
+    AddErrorInfo(GetErrorPrefix() + error_msg, error_line, error_column);
     ManifestUmaUtil::ParseFailed();
     failed_ = true;
     return;
   }
 
   base::DictionaryValue* dictionary = nullptr;
   if (!value->GetAsDictionary(&dictionary)) {
-    errors_.push_back(GetErrorPrefix() +
-                      "root element must be a valid JSON object.");
+    AddErrorInfo(GetErrorPrefix() +
+                 "root element must be a valid JSON object.");
     ManifestUmaUtil::ParseFailed();
     failed_ = true;
     return;
   }
   DCHECK(dictionary);
 
   manifest_.name = ParseName(*dictionary);
   manifest_.short_name = ParseShortName(*dictionary);
   manifest_.start_url = ParseStartURL(*dictionary);
   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);
 
   ManifestUmaUtil::ParseSucceeded(manifest_);
 }
 
 const Manifest& ManifestParser::manifest() const {
   return manifest_;
 }
 
-const std::vector<std::string>& ManifestParser::errors() const {
+const std::vector<scoped_ptr<ManifestParser::ErrorInfo>>&
+ManifestParser::errors() const {
   return errors_;
 }
 
 bool ManifestParser::failed() const {
   return failed_;
 }
 
 bool ManifestParser::ParseBoolean(const base::DictionaryValue& dictionary,
                                   const std::string& key,
                                   bool default_value) {
   if (!dictionary.HasKey(key))
     return default_value;
 
   bool value;
   if (!dictionary.GetBoolean(key, &value)) {
-    errors_.push_back(GetErrorPrefix() +
-                      "property '" + key + "' ignored, type boolean expected.");
+    AddErrorInfo(GetErrorPrefix() + "property '" + key + "' ignored, type " +
+                 "boolean expected.");
     return default_value;
   }
 
   return value;
 }
 
 base::NullableString16 ManifestParser::ParseString(
     const base::DictionaryValue& dictionary,
     const std::string& key,
     TrimType trim) {
   if (!dictionary.HasKey(key))
     return base::NullableString16();
 
   base::string16 value;
   if (!dictionary.GetString(key, &value)) {
-    errors_.push_back(GetErrorPrefix() +
-                      "property '" + key + "' ignored, type string expected.");
+    AddErrorInfo(GetErrorPrefix() + "property '" + key + "' ignored, type " +
+                 "string expected.");
     return base::NullableString16();
   }
 
   if (trim == Trim)
     base::TrimWhitespace(value, base::TRIM_ALL, &value);
   return base::NullableString16(value, false);
 }
 
 int64_t ManifestParser::ParseColor(
     const base::DictionaryValue& dictionary,
     const std::string& key) {
   base::NullableString16 parsed_color = ParseString(dictionary, key, Trim);
   if (parsed_color.is_null())
     return Manifest::kInvalidOrMissingColor;
 
   blink::WebColor color;
   if (!blink::WebCSSParser::parseColor(&color, parsed_color.string())) {
-      errors_.push_back(GetErrorPrefix() +
-                        "property '" + key + "' ignored, '" +
-                        base::UTF16ToUTF8(parsed_color.string()) +
-                        "' is not a valid color.");
+    AddErrorInfo(GetErrorPrefix() + "property '" + key + "' ignored, '" +
+                 base::UTF16ToUTF8(parsed_color.string()) + "' is not a " +
+                 "valid color.");
       return Manifest::kInvalidOrMissingColor;
   }
 
   // We do this here because Java does not have an unsigned int32_t type so
   // colors with high alpha values will be negative. Instead of doing the
   // conversion after we pass over to Java, we do it here as it is easier and
   // clearer.
   int32_t signed_color = reinterpret_cast<int32_t&>(color);
   return static_cast<int64_t>(signed_color);
 }
@@ skipping 17 matching lines @@
     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()) {
-    errors_.push_back(GetErrorPrefix() + "property 'start_url' ignored, should "
-                      "be same origin as document.");
+    AddErrorInfo(GetErrorPrefix() + "property 'start_url' ignored, should be " +
+                 "same origin as document.");
     return GURL();
   }
 
   return start_url;
 }
 
 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;
   else if (base::LowerCaseEqualsASCII(display.string(), "minimal-ui"))
     return blink::WebDisplayModeMinimalUi;
   else if (base::LowerCaseEqualsASCII(display.string(), "browser"))
     return blink::WebDisplayModeBrowser;
   else {
-    errors_.push_back(GetErrorPrefix() + "unknown 'display' value ignored.");
+    AddErrorInfo(GetErrorPrefix() + "unknown 'display' value ignored.");
     return blink::WebDisplayModeUndefined;
   }
 }
 
 blink::WebScreenOrientationLockType ManifestParser::ParseOrientation(
     const base::DictionaryValue& dictionary) {
   base::NullableString16 orientation =
       ParseString(dictionary, "orientation", Trim);
 
   if (orientation.is_null())
@@ skipping 13 matching lines @@
     return blink::WebScreenOrientationLockLandscapeSecondary;
   else if (base::LowerCaseEqualsASCII(orientation.string(), "portrait"))
     return blink::WebScreenOrientationLockPortrait;
   else if (base::LowerCaseEqualsASCII(orientation.string(),
                                       "portrait-primary"))
     return blink::WebScreenOrientationLockPortraitPrimary;
   else if (base::LowerCaseEqualsASCII(orientation.string(),
                                       "portrait-secondary"))
     return blink::WebScreenOrientationLockPortraitSecondary;
   else {
-    errors_.push_back(GetErrorPrefix() +
-                      "unknown 'orientation' value ignored.");
+    AddErrorInfo(GetErrorPrefix() + "unknown 'orientation' value ignored.");
     return blink::WebScreenOrientationLockDefault;
   }
 }
 
 GURL ManifestParser::ParseIconSrc(const base::DictionaryValue& icon) {
   return ParseURL(icon, "src", manifest_url_);
 }
 
 base::NullableString16 ManifestParser::ParseIconType(
     const base::DictionaryValue& icon) {
   return ParseString(icon, "type", Trim);
 }
 
 double ManifestParser::ParseIconDensity(const base::DictionaryValue& icon) {
   double density;
   if (!icon.HasKey("density"))
     return Manifest::Icon::kDefaultDensity;
 
   if (!icon.GetDouble("density", &density) || density <= 0) {
-    errors_.push_back(GetErrorPrefix() +
-                      "icon 'density' ignored, must be float greater than 0.");
+    AddErrorInfo(GetErrorPrefix() +
+                 "icon 'density' ignored, must be float greater than 0.");
     return Manifest::Icon::kDefaultDensity;
   }
   return density;
 }
 
 std::vector<gfx::Size> ManifestParser::ParseIconSizes(
     const base::DictionaryValue& icon) {
   base::NullableString16 sizes_str = ParseString(icon, "sizes", NoTrim);
 
   if (sizes_str.is_null())
     return std::vector<gfx::Size>();
 
   std::vector<gfx::Size> sizes = ParseIconSizesHTML(sizes_str.string());
   if (sizes.empty()) {
-    errors_.push_back(GetErrorPrefix() + "found icon with no valid size.");
+    AddErrorInfo(GetErrorPrefix() + "found icon with no valid size.");
   }
   return sizes;
 }
 
 std::vector<Manifest::Icon> ManifestParser::ParseIcons(
     const base::DictionaryValue& dictionary) {
   std::vector<Manifest::Icon> icons;
   if (!dictionary.HasKey("icons"))
     return icons;
 
   const base::ListValue* icons_list = nullptr;
   if (!dictionary.GetList("icons", &icons_list)) {
-    errors_.push_back(GetErrorPrefix() +
-                      "property 'icons' ignored, type array expected.");
+    AddErrorInfo(GetErrorPrefix() +
+                 "property 'icons' ignored, type array expected.");
     return icons;
   }
 
   for (size_t i = 0; i < icons_list->GetSize(); ++i) {
     const base::DictionaryValue* icon_dictionary = nullptr;
     if (!icons_list->GetDictionary(i, &icon_dictionary))
       continue;
 
     Manifest::Icon icon;
     icon.src = ParseIconSrc(*icon_dictionary);
@@ skipping 27 matching lines @@
 
 std::vector<Manifest::RelatedApplication>
 ManifestParser::ParseRelatedApplications(
     const base::DictionaryValue& dictionary) {
   std::vector<Manifest::RelatedApplication> applications;
   if (!dictionary.HasKey("related_applications"))
     return applications;
 
   const base::ListValue* applications_list = nullptr;
   if (!dictionary.GetList("related_applications", &applications_list)) {
-    errors_.push_back(
+    AddErrorInfo(
         GetErrorPrefix() +
         "property 'related_applications' ignored, type array expected.");
     return applications;
   }
 
   for (size_t i = 0; i < applications_list->GetSize(); ++i) {
     const base::DictionaryValue* application_dictionary = nullptr;
     if (!applications_list->GetDictionary(i, &application_dictionary))
       continue;
 
     Manifest::RelatedApplication application;
     application.platform =
         ParseRelatedApplicationPlatform(*application_dictionary);
     // "If platform is undefined, move onto the next item if any are left."
     if (application.platform.is_null()) {
-      errors_.push_back(
+      AddErrorInfo(
           GetErrorPrefix() +
           "'platform' is a required field, related application ignored.");
       continue;
     }
 
     application.id = ParseRelatedApplicationId(*application_dictionary);
     application.url = ParseRelatedApplicationURL(*application_dictionary);
     // "If both id and url are undefined, move onto the next item if any are
     // left."
     if (application.url.is_empty() && application.id.is_null()) {
-      errors_.push_back(
+      AddErrorInfo(
           GetErrorPrefix() +
           "one of 'url' or 'id' is required, related application ignored.");
       continue;
     }
 
     applications.push_back(application);
   }
 
   return applications;
 }
@@ skipping 11 matching lines @@
 int64_t ManifestParser::ParseBackgroundColor(
     const base::DictionaryValue& dictionary) {
   return ParseColor(dictionary, "background_color");
 }
 
 base::NullableString16 ManifestParser::ParseGCMSenderID(
     const base::DictionaryValue& dictionary)  {
   return ParseString(dictionary, "gcm_sender_id", Trim);
 }
 
+void ManifestParser::AddErrorInfo(const std::string& error_msg,
+                                  int error_line,
+                                  int error_column) {
+  errors_.push_back(
+      make_scoped_ptr(new ErrorInfo(error_msg, error_line, error_column)));
+}
 } // namespace content