[Doodle] Don't create invalid DoodleImages or DoodleConfigs

components/doodle/doodle_types.cc

 // Copyright 2017 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 "components/doodle/doodle_types.h"
 
 #include "base/values.h"
 
 namespace doodle {
 
@@ skipping 48 matching lines @@
   }
   return DoodleImage::FromDictionary(*image_dict, base_url);
 }
 
 }  // namespace
 
 // static
 base::Optional<DoodleImage> DoodleImage::FromDictionary(
     const base::DictionaryValue& dict,
     const base::Optional<GURL>& base_url) {
-  DoodleImage image;
-
   // The URL is the only required field.
-  image.url = ParseUrl(dict, "url", base_url);
-  if (!image.url.is_valid()) {
+  GURL url = ParseUrl(dict, "url", base_url);
+  if (!url.is_valid()) {
     return base::nullopt;
   }
 
+  DoodleImage image(url);
+
   dict.GetInteger("height", &image.height);
   dict.GetInteger("width", &image.width);
   dict.GetBoolean("is_animated_gif", &image.is_animated_gif);
   dict.GetBoolean("is_cta", &image.is_cta);
 
   return image;
 }
 
-DoodleImage::DoodleImage()
-    : height(0), width(0), is_animated_gif(false), is_cta(false) {}
+DoodleImage::DoodleImage(const GURL& url)
+    : url(url), height(0), width(0), is_animated_gif(false), is_cta(false) {
+  DCHECK(url.is_valid());
+}
+
 DoodleImage::~DoodleImage() = default;
 
 bool DoodleImage::operator==(const DoodleImage& other) const {
   return url == other.url && height == other.height && width == other.width &&
          is_animated_gif == other.is_animated_gif && is_cta == other.is_cta;
 }
 
 bool DoodleImage::operator!=(const DoodleImage& other) const {
   return !(*this == other);
 }
 
-DoodleConfig::DoodleConfig() : doodle_type(DoodleType::UNKNOWN) {}
+DoodleConfig::DoodleConfig(DoodleType doodle_type,
+                           const DoodleImage& large_image)
+    : doodle_type(doodle_type), large_image(large_image) {}
 DoodleConfig::DoodleConfig(const DoodleConfig& config) = default;
 DoodleConfig::~DoodleConfig() = default;
 
 // static
 base::Optional<DoodleConfig> DoodleConfig::FromDictionary(
     const base::DictionaryValue& dict,
     const base::Optional<GURL>& base_url) {
-  DoodleConfig doodle;
-
   // The |large_image| field is required (it's the "default" representation for
   // the doodle).
   base::Optional<DoodleImage> large_image =
       ParseImage(dict, "large_image", base_url);
   if (!large_image.has_value()) {
     return base::nullopt;
   }
-  doodle.large_image = large_image.value();
 
   std::string type_str;
   dict.GetString("doodle_type", &type_str);
-  doodle.doodle_type = DoodleTypeFromString(type_str);
+
+  DoodleConfig doodle(DoodleTypeFromString(type_str), large_image.value());
 
   dict.GetString("alt_text", &doodle.alt_text);
 
   dict.GetString("interactive_html", &doodle.interactive_html);
 
   doodle.search_url = ParseUrl(dict, "search_url", base_url);
   doodle.target_url = ParseUrl(dict, "target_url", base_url);
   doodle.fullpage_interactive_url =
       ParseUrl(dict, "fullpage_interactive_url", base_url);
 
@@ skipping 18 matching lines @@
          large_image == other.large_image &&
          large_cta_image == other.large_cta_image &&
          transparent_large_image == other.transparent_large_image;
 }
 
 bool DoodleConfig::operator!=(const DoodleConfig& other) const {
   return !(*this == other);
 }
 
 }  // namespace doodle