DevTools: Introduce Page.getManifest remote debugging protocol method.

content/renderer/manifest/manifest_parser_unittest.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 <stdint.h>
 
 #include <memory>
 
@@ skipping 15 matching lines @@
 class ManifestParserTest : public testing::Test  {
  protected:
   ManifestParserTest() {}
   ~ManifestParserTest() override {}
 
   Manifest ParseManifestWithURLs(const base::StringPiece& data,
                                  const GURL& document_url,
                                  const GURL& manifest_url) {
     ManifestParser parser(data, document_url, manifest_url);
     parser.Parse();
+    std::vector<ManifestDebugInfo::Error> errors;
+    parser.TakeErrors(&errors);
+
     errors_.clear();
-    for (const std::unique_ptr<ManifestParser::ErrorInfo>& error_info :
-         parser.errors()) {
-      errors_.push_back(error_info->error_msg);
-    }
+    for (const auto& error : errors)
+      errors_.push_back(error.message);
     return parser.manifest();
   }
 
   Manifest ParseManifest(const base::StringPiece& data) {
     return ParseManifestWithURLs(
         data, default_document_url, default_manifest_url);
   }
 
   const std::vector<std::string>& errors() const {
     return errors_;
@@ skipping 16 matching lines @@
     "http://foo.com/index.html");
 const GURL ManifestParserTest::default_manifest_url(
     "http://foo.com/manifest.json");
 
 TEST_F(ManifestParserTest, CrashTest) {
   // Passing temporary variables should not crash.
   ManifestParser parser("{\"start_url\": \"/\"}",
                         GURL("http://example.com"),
                         GURL("http://example.com"));
   parser.Parse();
+  std::vector<ManifestDebugInfo::Error> errors;
+  parser.TakeErrors(&errors);
 
   // .Parse() should have been call without crashing and succeeded.
-  EXPECT_EQ(0u, parser.errors().size());
+  EXPECT_EQ(0u, errors.size());
   EXPECT_FALSE(parser.manifest().IsEmpty());
 }
 
 TEST_F(ManifestParserTest, EmptyStringNull) {
   Manifest manifest = ParseManifest("");
 
   // This Manifest is not a valid JSON object, it's a parsing error.
   EXPECT_EQ(1u, GetErrorCount());
-  EXPECT_EQ("Manifest parsing error: Line: 1, column: 1, Unexpected token.",
+  EXPECT_EQ("Line: 1, column: 1, Unexpected token.",
             errors()[0]);
 
   // A parsing error is equivalent to an empty manifest.
   ASSERT_TRUE(manifest.IsEmpty());
   ASSERT_TRUE(manifest.name.is_null());
   ASSERT_TRUE(manifest.short_name.is_null());
   ASSERT_TRUE(manifest.start_url.is_empty());
   ASSERT_EQ(manifest.display, blink::WebDisplayModeUndefined);
   ASSERT_EQ(manifest.orientation, blink::WebScreenOrientationLockDefault);
   ASSERT_EQ(manifest.theme_color, Manifest::kInvalidOrMissingColor);
@@ skipping 20 matching lines @@
 }
 
 TEST_F(ManifestParserTest, MultipleErrorsReporting) {
   Manifest manifest = ParseManifest("{ \"name\": 42, \"short_name\": 4,"
       "\"orientation\": {}, \"display\": \"foo\","
       "\"start_url\": null, \"icons\": {}, \"theme_color\": 42,"
       "\"background_color\": 42 }");
 
   EXPECT_EQ(8u, GetErrorCount());
 
-  EXPECT_EQ("Manifest parsing error: property 'name' ignored,"
-            " type string expected.",
+  EXPECT_EQ("property 'name' ignored, type string expected.",
             errors()[0]);
-  EXPECT_EQ("Manifest parsing error: property 'short_name' ignored,"
-            " type string expected.",
+  EXPECT_EQ("property 'short_name' ignored, type string expected.",
             errors()[1]);
-  EXPECT_EQ("Manifest parsing error: property 'start_url' ignored,"
-            " type string expected.",
+  EXPECT_EQ("property 'start_url' ignored, type string expected.",
             errors()[2]);
-  EXPECT_EQ("Manifest parsing error: unknown 'display' value ignored.",
+  EXPECT_EQ("unknown 'display' value ignored.",
             errors()[3]);
-  EXPECT_EQ("Manifest parsing error: property 'orientation' ignored,"
-            " type string expected.",
+  EXPECT_EQ("property 'orientation' ignored, type string expected.",
             errors()[4]);
-  EXPECT_EQ("Manifest parsing error: property 'icons' ignored, "
-            "type array expected.",
+  EXPECT_EQ("property 'icons' ignored, type array expected.",
             errors()[5]);
-  EXPECT_EQ("Manifest parsing error: property 'theme_color' ignored,"
-            " type string expected.",
+  EXPECT_EQ("property 'theme_color' ignored, type string expected.",
             errors()[6]);
-  EXPECT_EQ("Manifest parsing error: property 'background_color' ignored,"
-            " type string expected.",
+  EXPECT_EQ("property 'background_color' ignored, type string expected.",
             errors()[7]);
 }
 
 TEST_F(ManifestParserTest, NameParseRules) {
   // Smoke test.
   {
     Manifest manifest = ParseManifest("{ \"name\": \"foo\" }");
     ASSERT_TRUE(base::EqualsASCII(manifest.name.string(), "foo"));
     ASSERT_FALSE(manifest.IsEmpty());
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Trim whitespaces.
   {
     Manifest manifest = ParseManifest("{ \"name\": \"  foo  \" }");
     ASSERT_TRUE(base::EqualsASCII(manifest.name.string(), "foo"));
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Don't parse if name isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"name\": {} }");
     ASSERT_TRUE(manifest.name.is_null());
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'name' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'name' ignored, type string expected.",
               errors()[0]);
   }
 
   // Don't parse if name isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"name\": 42 }");
     ASSERT_TRUE(manifest.name.is_null());
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'name' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'name' ignored, type string expected.",
               errors()[0]);
   }
 }
 
 TEST_F(ManifestParserTest, ShortNameParseRules) {
   // Smoke test.
   {
     Manifest manifest = ParseManifest("{ \"short_name\": \"foo\" }");
     ASSERT_TRUE(base::EqualsASCII(manifest.short_name.string(), "foo"));
     ASSERT_FALSE(manifest.IsEmpty());
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Trim whitespaces.
   {
     Manifest manifest = ParseManifest("{ \"short_name\": \"  foo  \" }");
     ASSERT_TRUE(base::EqualsASCII(manifest.short_name.string(), "foo"));
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Don't parse if name isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"short_name\": {} }");
     ASSERT_TRUE(manifest.short_name.is_null());
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'short_name' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'short_name' ignored, type string expected.",
               errors()[0]);
   }
 
   // Don't parse if name isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"short_name\": 42 }");
     ASSERT_TRUE(manifest.short_name.is_null());
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'short_name' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'short_name' ignored, type string expected.",
               errors()[0]);
   }
 }
 
 TEST_F(ManifestParserTest, StartURLParseRules) {
   // Smoke test.
   {
     Manifest manifest = ParseManifest("{ \"start_url\": \"land.html\" }");
     ASSERT_EQ(manifest.start_url.spec(),
               default_document_url.Resolve("land.html").spec());
     ASSERT_FALSE(manifest.IsEmpty());
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Whitespaces.
   {
     Manifest manifest = ParseManifest("{ \"start_url\": \"  land.html  \" }");
     ASSERT_EQ(manifest.start_url.spec(),
               default_document_url.Resolve("land.html").spec());
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Don't parse if property isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"start_url\": {} }");
     ASSERT_TRUE(manifest.start_url.is_empty());
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'start_url' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'start_url' ignored, type string expected.",
               errors()[0]);
   }
 
   // Don't parse if property isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"start_url\": 42 }");
     ASSERT_TRUE(manifest.start_url.is_empty());
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'start_url' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'start_url' ignored, type string expected.",
               errors()[0]);
   }
 
   // Absolute start_url, same origin with document.
   {
     Manifest manifest =
         ParseManifestWithURLs("{ \"start_url\": \"http://foo.com/land.html\" }",
                               GURL("http://foo.com/manifest.json"),
                               GURL("http://foo.com/index.html"));
     ASSERT_EQ(manifest.start_url.spec(), "http://foo.com/land.html");
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Absolute start_url, cross origin with document.
   {
     Manifest manifest =
         ParseManifestWithURLs("{ \"start_url\": \"http://bar.com/land.html\" }",
                               GURL("http://foo.com/manifest.json"),
                               GURL("http://foo.com/index.html"));
     ASSERT_TRUE(manifest.start_url.is_empty());
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'start_url' ignored, should "
+    EXPECT_EQ("property 'start_url' ignored, should "
               "be same origin as document.",
               errors()[0]);
   }
 
   // Resolving has to happen based on the manifest_url.
   {
     Manifest manifest =
         ParseManifestWithURLs("{ \"start_url\": \"land.html\" }",
                               GURL("http://foo.com/landing/manifest.json"),
                               GURL("http://foo.com/index.html"));
@@ skipping 16 matching lines @@
     Manifest manifest = ParseManifest("{ \"display\": \"  browser  \" }");
     EXPECT_EQ(manifest.display, blink::WebDisplayModeBrowser);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Don't parse if name isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"display\": {} }");
     EXPECT_EQ(manifest.display, blink::WebDisplayModeUndefined);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'display' ignored,"
+    EXPECT_EQ("property 'display' ignored,"
               " type string expected.",
               errors()[0]);
   }
 
   // Don't parse if name isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"display\": 42 }");
     EXPECT_EQ(manifest.display, blink::WebDisplayModeUndefined);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'display' ignored,"
+    EXPECT_EQ("property 'display' ignored,"
               " type string expected.",
               errors()[0]);
   }
 
   // Parse fails if string isn't known.
   {
     Manifest manifest = ParseManifest("{ \"display\": \"browser_something\" }");
     EXPECT_EQ(manifest.display, blink::WebDisplayModeUndefined);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: unknown 'display' value ignored.",
+    EXPECT_EQ("unknown 'display' value ignored.",
               errors()[0]);
   }
 
   // Accept 'fullscreen'.
   {
     Manifest manifest = ParseManifest("{ \"display\": \"fullscreen\" }");
     EXPECT_EQ(manifest.display, blink::WebDisplayModeFullscreen);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
@@ skipping 40 matching lines @@
     Manifest manifest = ParseManifest("{ \"orientation\": \"natural\" }");
     EXPECT_EQ(manifest.orientation, blink::WebScreenOrientationLockNatural);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Don't parse if name isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"orientation\": {} }");
     EXPECT_EQ(manifest.orientation, blink::WebScreenOrientationLockDefault);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'orientation' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'orientation' ignored, type string expected.",
               errors()[0]);
   }
 
   // Don't parse if name isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"orientation\": 42 }");
     EXPECT_EQ(manifest.orientation, blink::WebScreenOrientationLockDefault);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'orientation' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'orientation' ignored, type string expected.",
               errors()[0]);
   }
 
   // Parse fails if string isn't known.
   {
     Manifest manifest = ParseManifest("{ \"orientation\": \"naturalish\" }");
     EXPECT_EQ(manifest.orientation, blink::WebScreenOrientationLockDefault);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: unknown 'orientation' value ignored.",
+    EXPECT_EQ("unknown 'orientation' value ignored.",
               errors()[0]);
   }
 
   // Accept 'any'.
   {
     Manifest manifest = ParseManifest("{ \"orientation\": \"any\" }");
     EXPECT_EQ(manifest.orientation, blink::WebScreenOrientationLockAny);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
@@ skipping 124 matching lines @@
     EXPECT_EQ(manifest.icons[0].src.spec(),
               default_document_url.Resolve("foo.png").spec());
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Don't parse if property isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"icons\": [ {\"src\": {} } ] }");
     EXPECT_TRUE(manifest.icons.empty());
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'src' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'src' ignored, type string expected.",
               errors()[0]);
   }
 
   // Don't parse if property isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"icons\": [ {\"src\": 42 } ] }");
     EXPECT_TRUE(manifest.icons.empty());
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'src' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'src' ignored, type string expected.",
               errors()[0]);
   }
 
   // Resolving has to happen based on the document_url.
   {
     Manifest manifest = ParseManifestWithURLs(
         "{ \"icons\": [ {\"src\": \"icons/foo.png\" } ] }",
         GURL("http://foo.com/landing/index.html"),
         default_manifest_url);
     EXPECT_EQ(manifest.icons[0].src.spec(),
@@ skipping 18 matching lines @@
     EXPECT_TRUE(base::EqualsASCII(manifest.icons[0].type.string(), "foo"));
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Don't parse if property isn't a string.
   {
     Manifest manifest =
         ParseManifest("{ \"icons\": [ {\"src\": \"\", \"type\": {} } ] }");
     EXPECT_TRUE(manifest.icons[0].type.is_null());
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'type' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'type' ignored, type string expected.",
               errors()[0]);
   }
 
   // Don't parse if property isn't a string.
   {
     Manifest manifest =
         ParseManifest("{ \"icons\": [ {\"src\": \"\", \"type\": 42 } ] }");
     EXPECT_TRUE(manifest.icons[0].type.is_null());
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'type' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'type' ignored, type string expected.",
               errors()[0]);
   }
 }
 
 TEST_F(ManifestParserTest, IconSizesParseRules) {
   // Smoke test.
   {
     Manifest manifest = ParseManifest("{ \"icons\": [ {\"src\": \"\","
         "\"sizes\": \"42x42\" } ] }");
     EXPECT_EQ(manifest.icons[0].sizes.size(), 1u);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Trim whitespaces.
   {
     Manifest manifest = ParseManifest("{ \"icons\": [ {\"src\": \"\","
         "\"sizes\": \"  42x42  \" } ] }");
     EXPECT_EQ(manifest.icons[0].sizes.size(), 1u);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Ignore sizes if property isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"icons\": [ {\"src\": \"\","
         "\"sizes\": {} } ] }");
     EXPECT_EQ(manifest.icons[0].sizes.size(), 0u);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'sizes' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'sizes' ignored, type string expected.",
               errors()[0]);
   }
 
   // Ignore sizes if property isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"icons\": [ {\"src\": \"\","
         "\"sizes\": 42 } ] }");
     EXPECT_EQ(manifest.icons[0].sizes.size(), 0u);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'sizes' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'sizes' ignored, type string expected.",
               errors()[0]);
   }
 
   // Smoke test: value correctly parsed.
   {
     Manifest manifest = ParseManifest("{ \"icons\": [ {\"src\": \"\","
         "\"sizes\": \"42x42  48x48\" } ] }");
     EXPECT_EQ(manifest.icons[0].sizes[0], gfx::Size(42, 42));
     EXPECT_EQ(manifest.icons[0].sizes[1], gfx::Size(48, 48));
     EXPECT_EQ(0u, GetErrorCount());
@@ skipping 16 matching lines @@
     EXPECT_EQ(manifest.icons[0].sizes[1], gfx::Size(42, 42));
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Width or height can't start with 0.
   {
     Manifest manifest = ParseManifest("{ \"icons\": [ {\"src\": \"\","
         "\"sizes\": \"004X007  042x00\" } ] }");
     EXPECT_EQ(manifest.icons[0].sizes.size(), 0u);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: found icon with no valid size.",
+    EXPECT_EQ("found icon with no valid size.",
               errors()[0]);
   }
 
   // Width and height MUST contain digits.
   {
     Manifest manifest = ParseManifest("{ \"icons\": [ {\"src\": \"\","
         "\"sizes\": \"e4X1.0  55ax1e10\" } ] }");
     EXPECT_EQ(manifest.icons[0].sizes.size(), 0u);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: found icon with no valid size.",
+    EXPECT_EQ("found icon with no valid size.",
               errors()[0]);
   }
 
   // 'any' is correctly parsed and transformed to gfx::Size(0,0).
   {
     Manifest manifest = ParseManifest("{ \"icons\": [ {\"src\": \"\","
         "\"sizes\": \"any AnY ANY aNy\" } ] }");
     gfx::Size any = gfx::Size(0, 0);
     EXPECT_EQ(manifest.icons[0].sizes.size(), 4u);
     EXPECT_EQ(manifest.icons[0].sizes[0], any);
     EXPECT_EQ(manifest.icons[0].sizes[1], any);
     EXPECT_EQ(manifest.icons[0].sizes[2], any);
     EXPECT_EQ(manifest.icons[0].sizes[3], any);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Some invalid width/height combinations.
   {
     Manifest manifest = ParseManifest("{ \"icons\": [ {\"src\": \"\","
         "\"sizes\": \"x 40xx 1x2x3 x42 42xx42\" } ] }");
     gfx::Size any = gfx::Size(0, 0);
     EXPECT_EQ(manifest.icons[0].sizes.size(), 0u);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: found icon with no valid size.",
+    EXPECT_EQ("found icon with no valid size.",
               errors()[0]);
   }
 }
 
 TEST_F(ManifestParserTest, RelatedApplicationsParseRules) {
   // If no application, empty list.
   {
     Manifest manifest = ParseManifest(
         "{ \"related_applications\": []}");
     EXPECT_EQ(manifest.related_applications.size(), 0u);
     EXPECT_TRUE(manifest.IsEmpty());
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // If empty application, empty list.
   {
     Manifest manifest = ParseManifest(
         "{ \"related_applications\": [{}]}");
     EXPECT_EQ(manifest.related_applications.size(), 0u);
     EXPECT_TRUE(manifest.IsEmpty());
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: 'platform' is a required field, "
-              "related application ignored.",
+    EXPECT_EQ("'platform' is a required field, related application ignored.",
               errors()[0]);
   }
 
   // If invalid platform, application is ignored.
   {
     Manifest manifest = ParseManifest(
         "{ \"related_applications\": [{\"platform\": 123}]}");
     EXPECT_EQ(manifest.related_applications.size(), 0u);
     EXPECT_TRUE(manifest.IsEmpty());
     EXPECT_EQ(2u, GetErrorCount());
     EXPECT_EQ(
-        "Manifest parsing error: property 'platform' ignored, type string "
-        "expected.",
+        "property 'platform' ignored, type string expected.",
         errors()[0]);
-    EXPECT_EQ("Manifest parsing error: 'platform' is a required field, "
+    EXPECT_EQ("'platform' is a required field, "
               "related application ignored.",
               errors()[1]);
   }
 
   // If missing platform, application is ignored.
   {
     Manifest manifest = ParseManifest(
         "{ \"related_applications\": [{\"id\": \"foo\"}]}");
     EXPECT_EQ(manifest.related_applications.size(), 0u);
     EXPECT_TRUE(manifest.IsEmpty());
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: 'platform' is a required field, "
-              "related application ignored.",
+    EXPECT_EQ("'platform' is a required field, related application ignored.",
               errors()[0]);
   }
 
   // If missing id and url, application is ignored.
   {
     Manifest manifest = ParseManifest(
         "{ \"related_applications\": [{\"platform\": \"play\"}]}");
     EXPECT_EQ(manifest.related_applications.size(), 0u);
     EXPECT_TRUE(manifest.IsEmpty());
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: one of 'url' or 'id' is required, "
-              "related application ignored.",
+    EXPECT_EQ("one of 'url' or 'id' is required, related application ignored.",
               errors()[0]);
   }
 
   // Valid application, with url.
   {
     Manifest manifest = ParseManifest(
         "{ \"related_applications\": ["
         "{\"platform\": \"play\", \"url\": \"http://www.foo.com\"}]}");
     EXPECT_EQ(manifest.related_applications.size(), 1u);
     EXPECT_TRUE(base::EqualsASCII(
@@ skipping 50 matching lines @@
         "{\"platform\": \"play\", \"id\": \"foo\"},"
         "{}]}");
     EXPECT_EQ(manifest.related_applications.size(), 1u);
     EXPECT_TRUE(base::EqualsASCII(
         manifest.related_applications[0].platform.string(),
         "play"));
     EXPECT_TRUE(base::EqualsASCII(manifest.related_applications[0].id.string(),
                                   "foo"));
     EXPECT_FALSE(manifest.IsEmpty());
     EXPECT_EQ(2u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: one of 'url' or 'id' is required, "
-              "related application ignored.",
+    EXPECT_EQ("one of 'url' or 'id' is required, related application ignored.",
               errors()[0]);
-    EXPECT_EQ("Manifest parsing error: 'platform' is a required field, "
-              "related application ignored.",
+    EXPECT_EQ("'platform' is a required field, related application ignored.",
               errors()[1]);
   }
 }
 
 TEST_F(ManifestParserTest, ParsePreferRelatedApplicationsParseRules) {
   // Smoke test.
   {
     Manifest manifest =
         ParseManifest("{ \"prefer_related_applications\": true }");
     EXPECT_TRUE(manifest.prefer_related_applications);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Don't parse if the property isn't a boolean.
   {
     Manifest manifest =
         ParseManifest("{ \"prefer_related_applications\": {} }");
     EXPECT_FALSE(manifest.prefer_related_applications);
     EXPECT_EQ(1u, GetErrorCount());
     EXPECT_EQ(
-        "Manifest parsing error: property 'prefer_related_applications' "
+        "property 'prefer_related_applications' "
         "ignored, type boolean expected.",
         errors()[0]);
   }
   {
     Manifest manifest = ParseManifest(
         "{ \"prefer_related_applications\": \"true\" }");
     EXPECT_FALSE(manifest.prefer_related_applications);
     EXPECT_EQ(1u, GetErrorCount());
     EXPECT_EQ(
-        "Manifest parsing error: property 'prefer_related_applications' "
+        "property 'prefer_related_applications' "
         "ignored, type boolean expected.",
         errors()[0]);
   }
   {
     Manifest manifest = ParseManifest("{ \"prefer_related_applications\": 1 }");
     EXPECT_FALSE(manifest.prefer_related_applications);
     EXPECT_EQ(1u, GetErrorCount());
     EXPECT_EQ(
-        "Manifest parsing error: property 'prefer_related_applications' "
+        "property 'prefer_related_applications' "
         "ignored, type boolean expected.",
         errors()[0]);
   }
 
   // "False" should set the boolean false without throwing errors.
   {
     Manifest manifest =
         ParseManifest("{ \"prefer_related_applications\": false }");
     EXPECT_FALSE(manifest.prefer_related_applications);
     EXPECT_EQ(0u, GetErrorCount());
@@ skipping 14 matching lines @@
     Manifest manifest = ParseManifest("{ \"theme_color\": \"  blue   \" }");
     EXPECT_EQ(ExtractColor(manifest.theme_color), 0xFF0000FFu);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Don't parse if theme_color isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"theme_color\": {} }");
     EXPECT_EQ(manifest.theme_color, Manifest::kInvalidOrMissingColor);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'theme_color' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'theme_color' ignored, type string expected.",
               errors()[0]);
   }
 
   // Don't parse if theme_color isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"theme_color\": false }");
     EXPECT_EQ(manifest.theme_color, Manifest::kInvalidOrMissingColor);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'theme_color' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'theme_color' ignored, type string expected.",
               errors()[0]);
   }
 
   // Don't parse if theme_color isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"theme_color\": null }");
     EXPECT_EQ(manifest.theme_color, Manifest::kInvalidOrMissingColor);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'theme_color' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'theme_color' ignored, type string expected.",
               errors()[0]);
   }
 
   // Don't parse if theme_color isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"theme_color\": [] }");
     EXPECT_EQ(manifest.theme_color, Manifest::kInvalidOrMissingColor);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'theme_color' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'theme_color' ignored, type string expected.",
               errors()[0]);
   }
 
   // Don't parse if theme_color isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"theme_color\": 42 }");
     EXPECT_EQ(manifest.theme_color, Manifest::kInvalidOrMissingColor);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'theme_color' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'theme_color' ignored, type string expected.",
               errors()[0]);
   }
 
   // Parse fails if string is not in a known format.
   {
     Manifest manifest = ParseManifest("{ \"theme_color\": \"foo(bar)\" }");
     EXPECT_EQ(manifest.theme_color, Manifest::kInvalidOrMissingColor);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'theme_color' ignored,"
+    EXPECT_EQ("property 'theme_color' ignored,"
               " 'foo(bar)' is not a valid color.",
               errors()[0]);
   }
 
   // Parse fails if string is not in a known format.
   {
     Manifest manifest = ParseManifest("{ \"theme_color\": \"bleu\" }");
     EXPECT_EQ(manifest.theme_color, Manifest::kInvalidOrMissingColor);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'theme_color' ignored, 'bleu'"
-              " is not a valid color.",
+    EXPECT_EQ("property 'theme_color' ignored, 'bleu' is not a valid color.",
               errors()[0]);
   }
 
   // Parse fails if string is not in a known format.
   {
     Manifest manifest = ParseManifest("{ \"theme_color\": \"FF00FF\" }");
     EXPECT_EQ(manifest.theme_color, Manifest::kInvalidOrMissingColor);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'theme_color' ignored, 'FF00FF'"
+    EXPECT_EQ("property 'theme_color' ignored, 'FF00FF'"
               " is not a valid color.",
               errors()[0]);
   }
 
   // Parse fails if multiple values for theme_color are given.
   {
     Manifest manifest = ParseManifest("{ \"theme_color\": \"#ABC #DEF\" }");
     EXPECT_EQ(manifest.theme_color, Manifest::kInvalidOrMissingColor);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'theme_color' ignored, "
+    EXPECT_EQ("property 'theme_color' ignored, "
               "'#ABC #DEF' is not a valid color.",
               errors()[0]);
   }
 
   // Parse fails if multiple values for theme_color are given.
   {
     Manifest manifest = ParseManifest(
         "{ \"theme_color\": \"#AABBCC #DDEEFF\" }");
     EXPECT_EQ(manifest.theme_color, Manifest::kInvalidOrMissingColor);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'theme_color' ignored, "
+    EXPECT_EQ("property 'theme_color' ignored, "
               "'#AABBCC #DDEEFF' is not a valid color.",
               errors()[0]);
   }
 
   // Accept CSS color keyword format.
   {
     Manifest manifest = ParseManifest("{ \"theme_color\": \"blue\" }");
     EXPECT_EQ(ExtractColor(manifest.theme_color), 0xFF0000FFu);
     EXPECT_EQ(0u, GetErrorCount());
   }
@@ skipping 57 matching lines @@
         "{ \"background_color\": \"  blue   \" }");
     EXPECT_EQ(ExtractColor(manifest.background_color), 0xFF0000FFu);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Don't parse if background_color isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"background_color\": {} }");
     EXPECT_EQ(manifest.background_color, Manifest::kInvalidOrMissingColor);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'background_color' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'background_color' ignored, type string expected.",
               errors()[0]);
   }
 
   // Don't parse if background_color isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"background_color\": false }");
     EXPECT_EQ(manifest.background_color, Manifest::kInvalidOrMissingColor);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'background_color' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'background_color' ignored, type string expected.",
               errors()[0]);
   }
 
   // Don't parse if background_color isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"background_color\": null }");
     EXPECT_EQ(manifest.background_color, Manifest::kInvalidOrMissingColor);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'background_color' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'background_color' ignored, type string expected.",
               errors()[0]);
   }
 
   // Don't parse if background_color isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"background_color\": [] }");
     EXPECT_EQ(manifest.background_color, Manifest::kInvalidOrMissingColor);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'background_color' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'background_color' ignored, type string expected.",
               errors()[0]);
   }
 
   // Don't parse if background_color isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"background_color\": 42 }");
     EXPECT_EQ(manifest.background_color, Manifest::kInvalidOrMissingColor);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'background_color' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'background_color' ignored, type string expected.",
               errors()[0]);
   }
 
   // Parse fails if string is not in a known format.
   {
     Manifest manifest = ParseManifest("{ \"background_color\": \"foo(bar)\" }");
     EXPECT_EQ(manifest.background_color, Manifest::kInvalidOrMissingColor);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'background_color' ignored,"
+    EXPECT_EQ("property 'background_color' ignored,"
               " 'foo(bar)' is not a valid color.",
               errors()[0]);
   }
 
   // Parse fails if string is not in a known format.
   {
     Manifest manifest = ParseManifest("{ \"background_color\": \"bleu\" }");
     EXPECT_EQ(manifest.background_color, Manifest::kInvalidOrMissingColor);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'background_color' ignored,"
+    EXPECT_EQ("property 'background_color' ignored,"
               " 'bleu' is not a valid color.",
               errors()[0]);
   }
 
   // Parse fails if string is not in a known format.
   {
     Manifest manifest = ParseManifest("{ \"background_color\": \"FF00FF\" }");
     EXPECT_EQ(manifest.background_color, Manifest::kInvalidOrMissingColor);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'background_color' ignored,"
+    EXPECT_EQ("property 'background_color' ignored,"
               " 'FF00FF' is not a valid color.",
               errors()[0]);
   }
 
   // Parse fails if multiple values for background_color are given.
   {
     Manifest manifest = ParseManifest(
         "{ \"background_color\": \"#ABC #DEF\" }");
     EXPECT_EQ(manifest.background_color, Manifest::kInvalidOrMissingColor);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'background_color' ignored, "
+    EXPECT_EQ("property 'background_color' ignored, "
               "'#ABC #DEF' is not a valid color.",
               errors()[0]);
   }
 
   // Parse fails if multiple values for background_color are given.
   {
     Manifest manifest = ParseManifest(
         "{ \"background_color\": \"#AABBCC #DDEEFF\" }");
     EXPECT_EQ(manifest.background_color, Manifest::kInvalidOrMissingColor);
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'background_color' ignored, "
+    EXPECT_EQ("property 'background_color' ignored, "
               "'#AABBCC #DDEEFF' is not a valid color.",
               errors()[0]);
   }
 
   // Accept CSS color keyword format.
   {
     Manifest manifest = ParseManifest("{ \"background_color\": \"blue\" }");
     EXPECT_EQ(ExtractColor(manifest.background_color), 0xFF0000FFu);
     EXPECT_EQ(0u, GetErrorCount());
   }
@@ skipping 57 matching lines @@
     Manifest manifest = ParseManifest("{ \"gcm_sender_id\": \"  foo  \" }");
     EXPECT_TRUE(base::EqualsASCII(manifest.gcm_sender_id.string(), "foo"));
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Don't parse if the property isn't a string.
   {
     Manifest manifest = ParseManifest("{ \"gcm_sender_id\": {} }");
     EXPECT_TRUE(manifest.gcm_sender_id.is_null());
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'gcm_sender_id' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'gcm_sender_id' ignored, type string expected.",
               errors()[0]);
   }
   {
     Manifest manifest = ParseManifest("{ \"gcm_sender_id\": 42 }");
     EXPECT_TRUE(manifest.gcm_sender_id.is_null());
     EXPECT_EQ(1u, GetErrorCount());
-    EXPECT_EQ("Manifest parsing error: property 'gcm_sender_id' ignored,"
-              " type string expected.",
+    EXPECT_EQ("property 'gcm_sender_id' ignored, type string expected.",
               errors()[0]);
   }
 }
 
 } // namespace content