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

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 109 matching lines @@
     AddErrorInfo("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(
+base::Optional<SkColor> 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;
+    return base::nullopt;
 
   blink::WebColor color;
   if (!blink::WebCSSParser::parseColor(&color, parsed_color.string())) {
     AddErrorInfo("property '" + key + "' ignored, '" +
                  base::UTF16ToUTF8(parsed_color.string()) + "' is not a " +
                  "valid color.");
-      return Manifest::kInvalidOrMissingColor;
+    return base::nullopt;
   }
 
-  // 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);
+  return 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();
 
   GURL resolved = base_url.Resolve(url_str.string());
@@ skipping 225 matching lines @@
   }
 
   return applications;
 }
 
 bool ManifestParser::ParsePreferRelatedApplications(
     const base::DictionaryValue& dictionary) {
   return ParseBoolean(dictionary, "prefer_related_applications", false);
 }
 
-int64_t ManifestParser::ParseThemeColor(
+base::Optional<SkColor> ManifestParser::ParseThemeColor(
     const base::DictionaryValue& dictionary) {
   return ParseColor(dictionary, "theme_color");
 }
 
-int64_t ManifestParser::ParseBackgroundColor(
+base::Optional<SkColor> 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,
                                   bool critical,
                                   int error_line,
                                   int error_column) {
   errors_.push_back({error_msg, critical, error_line, error_column});
 }
 
 } // namespace content