Add a class to parse answer json.

components/omnibox/base_search_provider.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 "components/omnibox/base_search_provider.h"
 
 #include "base/i18n/case_conversion.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/metrics/proto/omnibox_event.pb.h"
 #include "components/metrics/proto/omnibox_input_type.pb.h"
 #include "components/omnibox/autocomplete_provider_client.h"
 #include "components/omnibox/autocomplete_provider_listener.h"
 #include "components/omnibox/omnibox_field_trial.h"
+#include "components/omnibox/suggestion_answer.h"
 #include "components/search_engines/template_url.h"
 #include "components/search_engines/template_url_prepopulate_data.h"
 #include "components/search_engines/template_url_service.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "url/gurl.h"
 
 using metrics::OmniboxEventProto;
 
@@ skipping 79 matching lines @@
     AutocompleteMatchType::Type type,
     bool from_keyword_provider,
     const TemplateURL* template_url,
     const SearchTermsData& search_terms_data) {
   // These calls use a number of default values.  For instance, they assume
   // that if this match is from a keyword provider, then the user is in keyword
   // mode.  They also assume the caller knows what it's doing and we set
   // this match to look as if it was received/created synchronously.
   SearchSuggestionParser::SuggestResult suggest_result(
       suggestion, type, suggestion, base::string16(), base::string16(),
-      base::string16(), base::string16(), std::string(), std::string(),
-      from_keyword_provider, 0, false, false, base::string16());
+      base::string16(), base::string16(), nullptr, std::string(),
+      std::string(), from_keyword_provider, 0, false, false, base::string16());
   suggest_result.set_received_after_last_keystroke(false);
   return CreateSearchSuggestion(
       NULL, AutocompleteInput(), from_keyword_provider, suggest_result,
       template_url, search_terms_data, 0, false);
 }
 
 void BaseSearchProvider::DeleteMatch(const AutocompleteMatch& match) {
   DCHECK(match.deletable);
   if (!match.GetAdditionalInfo(BaseSearchProvider::kDeletionUrlKey).empty()) {
     deletion_handlers_.push_back(new SuggestionDeletionHandler(
@@ skipping 75 matching lines @@
   AutocompleteMatch match(autocomplete_provider, suggestion.relevance(), false,
                           suggestion.type());
 
   if (!template_url)
     return match;
   match.keyword = template_url->keyword();
   match.contents = suggestion.match_contents();
   match.contents_class = suggestion.match_contents_class();
   match.answer_contents = suggestion.answer_contents();
   match.answer_type = suggestion.answer_type();
+  match.answer = SuggestionAnswer::copy(suggestion.answer());
   if (suggestion.type() == AutocompleteMatchType::SEARCH_SUGGEST_INFINITE) {
     match.RecordAdditionalInfo(
         kACMatchPropertyInputText, base::UTF16ToUTF8(input.text()));
     match.RecordAdditionalInfo(
         kACMatchPropertyContentsPrefix,
         base::UTF16ToUTF8(suggestion.match_contents_prefix()));
     match.RecordAdditionalInfo(
         kACMatchPropertyContentsStartIndex,
         static_cast<int>(
             suggestion.suggestion().length() - match.contents.length()));
@@ skipping 198 matching lines @@
         if (should_prefetch)
           i.first->second.RecordAdditionalInfo(kSuggestMetadataKey, metadata);
       }
     }
     // Copy over answer data from lower-ranking item, if necessary.
     // This depends on the lower-ranking item always being added last - see
     // use of push_back above.
     AutocompleteMatch& more_relevant_match = i.first->second;
     const AutocompleteMatch& less_relevant_match =
         more_relevant_match.duplicate_matches.back();
-    if (!less_relevant_match.answer_type.empty() &&
-        more_relevant_match.answer_type.empty()) {
+    if (less_relevant_match.answer && !more_relevant_match.answer) {
       more_relevant_match.answer_type = less_relevant_match.answer_type;
       more_relevant_match.answer_contents = less_relevant_match.answer_contents;
+      more_relevant_match.answer =
+          SuggestionAnswer::copy(less_relevant_match.answer.get());
     }
   }
 }
 
 bool BaseSearchProvider::ParseSuggestResults(
     const base::Value& root_val,
     int default_result_relevance,
     bool is_keyword_result,
     SearchSuggestionParser::Results* results) {
   if (!SearchSuggestionParser::ParseSuggestResults(
       root_val, GetInput(is_keyword_result),
       client_->SchemeClassifier(), default_result_relevance,
       client_->AcceptLanguages(), is_keyword_result, results))
     return false;
 
-  for (std::vector<GURL>::const_iterator it =
-           results->answers_image_urls.begin();
-       it != results->answers_image_urls.end(); ++it)
-    client_->PrefetchImage(*it);
+  for (const GURL& url : results->answers_image_urls)
+    client_->PrefetchImage(url);
 
   field_trial_triggered_ |= results->field_trial_triggered;
   field_trial_triggered_in_session_ |= results->field_trial_triggered;
   return true;
 }
 
 void BaseSearchProvider::DeleteMatchFromMatches(
     const AutocompleteMatch& match) {
   for (ACMatches::iterator i(matches_.begin()); i != matches_.end(); ++i) {
     // Find the desired match to delete by checking the type and contents.
     // We can't check the destination URL, because the autocomplete controller
     // may have reformulated that. Not that while checking for matching
     // contents works for personalized suggestions, if more match types gain
     // deletion support, this algorithm may need to be re-examined.
     if (i->contents == match.contents && i->type == match.type) {
       matches_.erase(i);
       break;
     }
   }
 }
 
 void BaseSearchProvider::OnDeletionComplete(
     bool success, SuggestionDeletionHandler* handler) {
   RecordDeletionResult(success);
   SuggestionDeletionHandlers::iterator it = std::find(
       deletion_handlers_.begin(), deletion_handlers_.end(), handler);
   DCHECK(it != deletion_handlers_.end());
   deletion_handlers_.erase(it);
 }