[AiS] Extract Answers, store on AutocompleteMatch.

chrome/browser/autocomplete/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 "chrome/browser/autocomplete/base_search_provider.h"
 
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/json/json_string_value_serializer.h"
+#include "base/json/json_writer.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_provider_listener.h"
 #include "chrome/browser/autocomplete/url_prefix.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/omnibox/omnibox_field_trial.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 115 matching lines @@
 
 // static
 AutocompleteMatch BaseSearchProvider::CreateSearchSuggestion(
     const base::string16& suggestion,
     AutocompleteMatchType::Type type,
     bool from_keyword_provider,
     const TemplateURL* template_url) {
   return CreateSearchSuggestion(
       NULL, AutocompleteInput(), BaseSearchProvider::SuggestResult(
           suggestion, type, suggestion, base::string16(), base::string16(),
-          std::string(), std::string(), from_keyword_provider, 0, false, false,
-          base::string16()),
+          base::string16(), base::string16(), std::string(), std::string(),
+          from_keyword_provider, 0, false, false, base::string16()),
       template_url, 0, 0, false, false);
 }
 
 void BaseSearchProvider::Stop(bool clear_cached_results) {
   StopSuggest();
   done_ = true;
 
   if (clear_cached_results)
     ClearAllResults();
 }
@@ skipping 68 matching lines @@
 BaseSearchProvider::Result::~Result() {}
 
 // BaseSearchProvider::SuggestResult -------------------------------------------
 
 BaseSearchProvider::SuggestResult::SuggestResult(
     const base::string16& suggestion,
     AutocompleteMatchType::Type type,
     const base::string16& match_contents,
     const base::string16& match_contents_prefix,
     const base::string16& annotation,
+    const base::string16& answer_contents,
+    const base::string16& answer_type,
     const std::string& suggest_query_params,
     const std::string& deletion_url,
     bool from_keyword_provider,
     int relevance,
     bool relevance_from_server,
     bool should_prefetch,
     const base::string16& input_text)
     : Result(from_keyword_provider,
              relevance,
              relevance_from_server,
              type,
              deletion_url),
       suggestion_(suggestion),
       match_contents_prefix_(match_contents_prefix),
       annotation_(annotation),
       suggest_query_params_(suggest_query_params),
+      answer_contents_(answer_contents),
+      answer_type_(answer_type),
       should_prefetch_(should_prefetch) {
   match_contents_ = match_contents;
   DCHECK(!match_contents_.empty());
   ClassifyMatchContents(true, input_text);
 }
 
 BaseSearchProvider::SuggestResult::~SuggestResult() {}
 
 void BaseSearchProvider::SuggestResult::ClassifyMatchContents(
     const bool allow_bolding_all,
@@ skipping 220 matching lines @@
     bool append_extra_query_params,
     bool from_app_list) {
   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();
   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 380 matching lines @@
         if (descriptions != NULL)
           descriptions->GetString(index, &title);
         results->navigation_results.push_back(NavigationResult(
             *this, url, match_type, title, deletion_url, is_keyword_result,
             relevance, relevances != NULL, input.text(), languages));
       }
     } else {
       base::string16 match_contents = suggestion;
       base::string16 match_contents_prefix;
       base::string16 annotation;
+      base::string16 answer_contents;
+      base::string16 answer_type;
       std::string suggest_query_params;
 
       if (suggestion_details) {
         suggestion_details->GetDictionary(index, &suggestion_detail);
         if (suggestion_detail) {
           suggestion_detail->GetString("t", &match_contents);
           suggestion_detail->GetString("mp", &match_contents_prefix);
           // Error correction for bad data from server.
           if (match_contents.empty())
             match_contents = suggestion;
           suggestion_detail->GetString("a", &annotation);
           suggestion_detail->GetString("q", &suggest_query_params);
+
+          // Extract Answers, if provided.
+          const base::DictionaryValue* answer_json = NULL;
+          if (suggestion_detail->GetDictionary("ansa", &answer_json)) {
+            std::string contents;
+            base::JSONWriter::Write(answer_json, &contents);
+            answer_contents = base::UTF8ToUTF16(contents);
+            suggestion_detail->GetString("ansb", &answer_type);
+          }
         }
       }
 
       bool should_prefetch = static_cast<int>(index) == prefetch_index;
       // TODO(kochi): Improve calculator suggestion presentation.
       results->suggest_results.push_back(SuggestResult(
           base::CollapseWhitespace(suggestion, false), match_type,
           base::CollapseWhitespace(match_contents, false),
-          match_contents_prefix, annotation, suggest_query_params,
-          deletion_url, is_keyword_result, relevance, relevances != NULL,
-          should_prefetch, trimmed_input));
+          match_contents_prefix, annotation, answer_contents, answer_type,
+          suggest_query_params, deletion_url, is_keyword_result, relevance,
+          relevances != NULL, should_prefetch, trimmed_input));
     }
   }
   SortResults(is_keyword_result, relevances, results);
   return true;
 }
 
 void BaseSearchProvider::SortResults(bool is_keyword,
                                      const base::ListValue* relevances,
                                      Results* results) {
 }
@@ skipping 24 matching lines @@
 }
 
 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);
 }