Remove deprecated Doodle search URLs

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/memory/ptr_util.h"
 #include "base/values.h"
 
 namespace doodle {
@@ skipping 13 matching lines @@
 const char kKeyUrl[] = "url";
 const char kKeyHeight[] = "height";
 const char kKeyWidth[] = "width";
 const char kKeyIsAnimatedGif[] = "is_animated_gif";
 const char kKeyIsCta[] = "is_cta";
 
 // JSON keys for DoodleConfig fields.
 const char kKeyDoodleType[] = "doodle_type";
 const char kKeyAltText[] = "alt_text";
 const char kKeyInteractiveHtml[] = "interactive_html";
-const char kKeySearchUrl[] = "search_url";
 const char kKeyTargetUrl[] = "target_url";
-const char kKeyFullpageInteractiveUrl[] = "fullpage_interactive_url";
 const char kKeyLargeImage[] = "large_image";
 const char kKeyLargeCtaImage[] = "large_cta_image";
 const char kKeyTransparentLargeImage[] = "transparent_large_image";
 
 std::string DoodleTypeToString(DoodleType type) {
   switch (type) {
     case DoodleType::UNKNOWN:
       return kDoodleTypeUnknown;
     case DoodleType::SIMPLE:
       return kDoodleTypeSimple;
@@ skipping 130 matching lines @@
 
   std::string type_str;
   dict.GetString(kKeyDoodleType, &type_str);
 
   DoodleConfig doodle(DoodleTypeFromString(type_str), large_image.value());
 
   dict.GetString(kKeyAltText, &doodle.alt_text);
 
   dict.GetString(kKeyInteractiveHtml, &doodle.interactive_html);
 
-  doodle.search_url = ParseUrl(dict, kKeySearchUrl, base_url);
   doodle.target_url = ParseUrl(dict, kKeyTargetUrl, base_url);
-  doodle.fullpage_interactive_url =
-      ParseUrl(dict, kKeyFullpageInteractiveUrl, base_url);
 
   doodle.large_cta_image = ParseImage(dict, kKeyLargeCtaImage, base_url);
   doodle.transparent_large_image =
       ParseImage(dict, kKeyTransparentLargeImage, base_url);
 
   return doodle;
 }
 
 std::unique_ptr<base::DictionaryValue> DoodleConfig::ToDictionary() const {
   auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetString(kKeyDoodleType, DoodleTypeToString(doodle_type));
   dict->SetString(kKeyAltText, alt_text);
   dict->SetString(kKeyInteractiveHtml, interactive_html);
-  dict->SetString(kKeySearchUrl, search_url.spec());
   dict->SetString(kKeyTargetUrl, target_url.spec());
-  dict->SetString(kKeyFullpageInteractiveUrl, fullpage_interactive_url.spec());
   dict->Set(kKeyLargeImage, large_image.ToDictionary());
   if (large_cta_image.has_value()) {
     dict->Set(kKeyLargeCtaImage, large_cta_image->ToDictionary());
   }
   if (transparent_large_image.has_value()) {
     dict->Set(kKeyTransparentLargeImage,
               transparent_large_image->ToDictionary());
   }
   return dict;
 }
 
 bool DoodleConfig::operator==(const DoodleConfig& other) const {
   return doodle_type == other.doodle_type && alt_text == other.alt_text &&
          interactive_html == other.interactive_html &&
-         search_url == other.search_url && target_url == other.target_url &&
-         fullpage_interactive_url == other.fullpage_interactive_url &&
          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