[WIP] Use Optional<SkColor> instead of int64 for colors in Manifest.

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>
 
 #include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "content/public/common/manifest.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
-namespace {
-
-uint32_t ExtractColor(int64_t color) {
-  return reinterpret_cast<uint32_t&>(color);
-}
-
-} // anonymous namespace
-
 class ManifestParserTest : public testing::Test  {
  protected:
   ManifestParserTest() {}
   ~ManifestParserTest() override {}
 
   Manifest ParseManifestWithURLs(const base::StringPiece& data,
                                  const GURL& manifest_url,
                                  const GURL& document_url) {
     ManifestParser parser(data, manifest_url, document_url);
     parser.Parse();
@@ skipping 55 matching lines @@
   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);
-  ASSERT_EQ(manifest.background_color, Manifest::kInvalidOrMissingColor);
+  ASSERT_FALSE(manifest.theme_color.has_value());
+  ASSERT_FALSE(manifest.background_color.has_value());
   ASSERT_TRUE(manifest.gcm_sender_id.is_null());
   ASSERT_TRUE(manifest.scope.is_empty());
 }
 
 TEST_F(ManifestParserTest, ValidNoContentParses) {
   Manifest manifest = ParseManifest("{}");
 
   // Empty Manifest is not a parsing error.
   EXPECT_EQ(0u, GetErrorCount());
 
   // Check that all the fields are null in that case.
   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);
-  ASSERT_EQ(manifest.background_color, Manifest::kInvalidOrMissingColor);
+  ASSERT_FALSE(manifest.theme_color.has_value());
+  ASSERT_FALSE(manifest.background_color.has_value());
   ASSERT_TRUE(manifest.gcm_sender_id.is_null());
   ASSERT_TRUE(manifest.scope.is_empty());
 }
 
 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 }");
 
@@ skipping 924 matching lines @@
         ParseManifest("{ \"prefer_related_applications\": false }");
     EXPECT_FALSE(manifest.prefer_related_applications);
     EXPECT_EQ(0u, GetErrorCount());
   }
 }
 
 TEST_F(ManifestParserTest, ThemeColorParserRules) {
   // Smoke test.
   {
     Manifest manifest = ParseManifest("{ \"theme_color\": \"#FF0000\" }");
-    EXPECT_EQ(ExtractColor(manifest.theme_color), 0xFFFF0000u);
+    EXPECT_EQ(0xFFFF0000, manifest.theme_color);
     EXPECT_FALSE(manifest.IsEmpty());
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Trim whitespaces.
   {
     Manifest manifest = ParseManifest("{ \"theme_color\": \"  blue   \" }");
-    EXPECT_EQ(ExtractColor(manifest.theme_color), 0xFF0000FFu);
+    EXPECT_EQ(0xFF0000FFu, manifest.theme_color);
     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_FALSE(manifest.theme_color.has_value());
     EXPECT_EQ(1u, GetErrorCount());
     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_FALSE(manifest.theme_color.has_value());
     EXPECT_EQ(1u, GetErrorCount());
     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_FALSE(manifest.theme_color.has_value());
     EXPECT_EQ(1u, GetErrorCount());
     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_FALSE(manifest.theme_color.has_value());
     EXPECT_EQ(1u, GetErrorCount());
     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_FALSE(manifest.theme_color.has_value());
     EXPECT_EQ(1u, GetErrorCount());
     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_FALSE(manifest.theme_color.has_value());
     EXPECT_EQ(1u, GetErrorCount());
     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_FALSE(manifest.theme_color.has_value());
     EXPECT_EQ(1u, GetErrorCount());
     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_FALSE(manifest.theme_color.has_value());
     EXPECT_EQ(1u, GetErrorCount());
     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_FALSE(manifest.theme_color.has_value());
     EXPECT_EQ(1u, GetErrorCount());
     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_FALSE(manifest.theme_color.has_value());
     EXPECT_EQ(1u, GetErrorCount());
     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(0xFF0000FFu, manifest.theme_color);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Accept CSS color keyword format.
   {
     Manifest manifest = ParseManifest("{ \"theme_color\": \"chartreuse\" }");
-    EXPECT_EQ(ExtractColor(manifest.theme_color), 0xFF7FFF00u);
+    EXPECT_EQ(0xFF7FFF00u, manifest.theme_color);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Accept CSS RGB format.
   {
     Manifest manifest = ParseManifest("{ \"theme_color\": \"#FFF\" }");
-    EXPECT_EQ(ExtractColor(manifest.theme_color), 0xFFFFFFFFu);
+    EXPECT_EQ(0xFFFFFFFFu, manifest.theme_color);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Accept CSS RGB format.
   {
     Manifest manifest = ParseManifest("{ \"theme_color\": \"#ABC\" }");
-    EXPECT_EQ(ExtractColor(manifest.theme_color), 0xFFAABBCCu);
+    EXPECT_EQ(0xFFAABBCCu, manifest.theme_color);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Accept CSS RRGGBB format.
   {
     Manifest manifest = ParseManifest("{ \"theme_color\": \"#FF0000\" }");
-    EXPECT_EQ(ExtractColor(manifest.theme_color), 0xFFFF0000u);
+    EXPECT_EQ(0xFFFF0000u, manifest.theme_color);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Accept translucent colors.
   {
     Manifest manifest = ParseManifest("{ \"theme_color\": \"rgba(255,0,0,"
         "0.4)\" }");
-    EXPECT_EQ(ExtractColor(manifest.theme_color), 0x66FF0000u);
+    EXPECT_EQ(0x66FF0000u, manifest.theme_color);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Accept transparent colors.
   {
     Manifest manifest = ParseManifest("{ \"theme_color\": \"rgba(0,0,0,0)\" }");
-    EXPECT_EQ(ExtractColor(manifest.theme_color), 0x00000000u);
+    EXPECT_EQ(0x00000000u, manifest.theme_color);
     EXPECT_EQ(0u, GetErrorCount());
   }
 }
 
 TEST_F(ManifestParserTest, BackgroundColorParserRules) {
   // Smoke test.
   {
     Manifest manifest = ParseManifest("{ \"background_color\": \"#FF0000\" }");
-    EXPECT_EQ(ExtractColor(manifest.background_color), 0xFFFF0000u);
+    EXPECT_EQ(0xFFFF0000u, manifest.background_color);
     EXPECT_FALSE(manifest.IsEmpty());
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Trim whitespaces.
   {
     Manifest manifest = ParseManifest(
         "{ \"background_color\": \"  blue   \" }");
-    EXPECT_EQ(ExtractColor(manifest.background_color), 0xFF0000FFu);
+    EXPECT_EQ(0xFF0000FFu, manifest.background_color);
     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_FALSE(manifest.background_color.has_value());
     EXPECT_EQ(1u, GetErrorCount());
     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_FALSE(manifest.background_color.has_value());
     EXPECT_EQ(1u, GetErrorCount());
     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_FALSE(manifest.background_color.has_value());
     EXPECT_EQ(1u, GetErrorCount());
     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_FALSE(manifest.background_color.has_value());
     EXPECT_EQ(1u, GetErrorCount());
     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_FALSE(manifest.background_color.has_value());
     EXPECT_EQ(1u, GetErrorCount());
     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_FALSE(manifest.background_color.has_value());
     EXPECT_EQ(1u, GetErrorCount());
     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_FALSE(manifest.background_color.has_value());
     EXPECT_EQ(1u, GetErrorCount());
     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_FALSE(manifest.background_color.has_value());
     EXPECT_EQ(1u, GetErrorCount());
     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_FALSE(manifest.background_color.has_value());
     EXPECT_EQ(1u, GetErrorCount());
     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_FALSE(manifest.background_color.has_value());
     EXPECT_EQ(1u, GetErrorCount());
     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(0xFF0000FFu, manifest.background_color);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Accept CSS color keyword format.
   {
     Manifest manifest = ParseManifest(
         "{ \"background_color\": \"chartreuse\" }");
-    EXPECT_EQ(ExtractColor(manifest.background_color), 0xFF7FFF00u);
+    EXPECT_EQ(0xFF7FFF00u, manifest.background_color);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Accept CSS RGB format.
   {
     Manifest manifest = ParseManifest("{ \"background_color\": \"#FFF\" }");
-    EXPECT_EQ(ExtractColor(manifest.background_color), 0xFFFFFFFFu);
+    EXPECT_EQ(0xFFFFFFFFu, manifest.background_color);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Accept CSS RGB format.
   {
     Manifest manifest = ParseManifest("{ \"background_color\": \"#ABC\" }");
-    EXPECT_EQ(ExtractColor(manifest.background_color), 0xFFAABBCCu);
+    EXPECT_EQ(0xFFAABBCCu, manifest.background_color);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Accept CSS RRGGBB format.
   {
     Manifest manifest = ParseManifest("{ \"background_color\": \"#FF0000\" }");
-    EXPECT_EQ(ExtractColor(manifest.background_color), 0xFFFF0000u);
+    EXPECT_EQ(0xFFFF0000, manifest.background_color);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Accept translucent colors.
   {
     Manifest manifest = ParseManifest("{ \"background_color\": \"rgba(255,0,0,"
         "0.4)\" }");
-    EXPECT_EQ(ExtractColor(manifest.background_color), 0x66FF0000u);
+    EXPECT_EQ(0x66FF0000u, manifest.background_color);
     EXPECT_EQ(0u, GetErrorCount());
   }
 
   // Accept transparent colors.
   {
     Manifest manifest = ParseManifest("{ \"background_color\": \"rgba(0,0,0,"
         "0)\" }");
-    EXPECT_EQ(ExtractColor(manifest.background_color), 0x00000000u);
+    EXPECT_EQ(0x00000000u, manifest.background_color);
     EXPECT_EQ(0u, GetErrorCount());
   }
 }
 
 TEST_F(ManifestParserTest, GCMSenderIDParseRules) {
   // Smoke test.
   {
     Manifest manifest = ParseManifest("{ \"gcm_sender_id\": \"foo\" }");
     EXPECT_TRUE(base::EqualsASCII(manifest.gcm_sender_id.string(), "foo"));
     EXPECT_EQ(0u, GetErrorCount());
@@ skipping 17 matching lines @@
   {
     Manifest manifest = ParseManifest("{ \"gcm_sender_id\": 42 }");
     EXPECT_TRUE(manifest.gcm_sender_id.is_null());
     EXPECT_EQ(1u, GetErrorCount());
     EXPECT_EQ("property 'gcm_sender_id' ignored, type string expected.",
               errors()[0]);
   }
 }
 
 } // namespace content