Move DeserializeJsonData() and UTF-8 conversion code to SearchSuggestionParser

components/autocomplete/search_suggestion_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 "components/autocomplete/search_suggestion_parser.h"
 
+#include "base/i18n/icu_string_conversions.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "components/autocomplete/autocomplete_input.h"
 #include "components/autocomplete/url_prefix.h"
 #include "components/url_fixer/url_fixer.h"
 #include "net/base/net_util.h"
+#include "net/http/http_response_headers.h"
+#include "net/url_request/url_fetcher.h"
 
 namespace {
 
 AutocompleteMatchType::Type GetAutocompleteMatchType(const std::string& type) {
   if (type == "ENTITY")
     return AutocompleteMatchType::SEARCH_SUGGEST_ENTITY;
   if (type == "INFINITE")
     return AutocompleteMatchType::SEARCH_SUGGEST_INFINITE;
   if (type == "PERSONALIZED_QUERY")
     return AutocompleteMatchType::SEARCH_SUGGEST_PERSONALIZED;
@@ skipping 205 matching lines @@
 int SearchSuggestionParser::NavigationResult::CalculateRelevance(
     const AutocompleteInput& input,
     bool keyword_provider_requested) const {
   return (from_keyword_provider_ || !keyword_provider_requested) ? 800 : 150;
 }
 
 // SearchSuggestionParser::Results ---------------------------------------------
 
 SearchSuggestionParser::Results::Results()
     : verbatim_relevance(-1),
-      field_trial_triggered(false) {}
+      field_trial_triggered(false),
+      relevances_from_server(false) {}
 
 SearchSuggestionParser::Results::~Results() {}
 
 void SearchSuggestionParser::Results::Clear() {
   suggest_results.clear();
   navigation_results.clear();
   verbatim_relevance = -1;
   metadata.clear();
 }
 
@@ skipping 14 matching lines @@
     if (i->relevance_from_server())
       return true;
   }
 
   return false;
 }
 
 // SearchSuggestionParser ------------------------------------------------------
 
 // static
+std::string SearchSuggestionParser::ExtractJsonData(
+    const net::URLFetcher* source) {
+  const net::HttpResponseHeaders* const response_headers =
+      source->GetResponseHeaders();
+  std::string json_data;
+  source->GetResponseAsString(&json_data);
+
+  // JSON is supposed to be UTF-8, but some suggest service providers send
+  // JSON files in non-UTF-8 encodings.  The actual encoding is usually
+  // specified in the Content-Type header field.
+  if (response_headers) {
+    std::string charset;
+    if (response_headers->GetCharset(&charset)) {
+      base::string16 data_16;
+      // TODO(jungshik): Switch to CodePageToUTF8 after it's added.
+      if (base::CodepageToUTF16(json_data, charset.c_str(),
+                                base::OnStringConversionError::FAIL,
+                                &data_16))
+        json_data = base::UTF16ToUTF8(data_16);
+    }
+  }
+  return json_data;
+}
+
+// static
+scoped_ptr<base::Value> SearchSuggestionParser::DeserializeJsonData(
+    std::string json_data) {
+  // The JSON response should be an array.
+  for (size_t response_start_index = json_data.find("["), i = 0;
+       response_start_index != std::string::npos && i < 5;
+       response_start_index = json_data.find("[", 1), i++) {
+    // Remove any XSSI guards to allow for JSON parsing.
+    if (response_start_index > 0)
+      json_data.erase(0, response_start_index);
+
+    JSONStringValueSerializer deserializer(json_data);
+    deserializer.set_allow_trailing_comma(true);
+    int error_code = 0;
+    scoped_ptr<base::Value> data(deserializer.Deserialize(&error_code, NULL));
+    if (error_code == 0)
+      return data.Pass();
+  }
+  return scoped_ptr<base::Value>();
+}
+
+// static
 bool SearchSuggestionParser::ParseSuggestResults(
     const base::Value& root_val,
     const AutocompleteInput& input,
     const AutocompleteSchemeClassifier& scheme_classifier,
-    const ImagePrefetchCallback& image_prefetch_callback,
     int default_result_relevance,
     const std::string& languages,
     bool is_keyword_result,
-    bool* relevances_from_server,
     Results* results) {
   base::string16 query;
   const base::ListValue* root_list = NULL;
   const base::ListValue* results_list = NULL;
 
   if (!root_val.GetAsList(&root_list) || !root_list->GetString(0, &query) ||
       query != input.text() || !root_list->GetList(1, &results_list))
     return false;
 
   // 3rd element: Description list.
@@ skipping 37 matching lines @@
 
     // Store the metadata that came with the response in case we need to pass it
     // along with the prefetch query to Instant.
     JSONStringValueSerializer json_serializer(&results->metadata);
     json_serializer.Serialize(*extras);
   }
 
   // Clear the previous results now that new results are available.
   results->suggest_results.clear();
   results->navigation_results.clear();
+  results->answers_image_urls.clear();
 
   base::string16 suggestion;
   std::string type;
   int relevance = default_result_relevance;
   // Prohibit navsuggest in FORCED_QUERY mode.  Users wants queries, not URLs.
   const bool allow_navsuggest =
       input.type() != metrics::OmniboxInputType::FORCED_QUERY;
   const base::string16& trimmed_input =
       base::CollapseWhitespace(input.text(), false);
   for (size_t index = 0; results_list->GetString(index, &suggestion); ++index) {
@@ skipping 46 matching lines @@
           // 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)) {
             match_type = AutocompleteMatchType::SEARCH_SUGGEST_ANSWER;
-            if (!image_prefetch_callback.is_null())
-              PrefetchAnswersImages(answer_json, image_prefetch_callback);
+            GetAnswersImageURLs(answer_json, &results->answers_image_urls);
             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, answer_contents, answer_type,
           suggest_query_params, deletion_url, is_keyword_result, relevance,
           relevances != NULL, should_prefetch, trimmed_input));
     }
   }
-  *relevances_from_server = relevances != NULL;
+  results->relevances_from_server = relevances != NULL;
   return true;
 }
 
 // static
-void SearchSuggestionParser::PrefetchAnswersImages(
+void SearchSuggestionParser::GetAnswersImageURLs(
     const base::DictionaryValue* answer_json,
-    const ImagePrefetchCallback& image_prefetch_callback) {
+    std::vector<GURL>* urls) {
   DCHECK(answer_json);
-  DCHECK(!image_prefetch_callback.is_null());
   const base::ListValue* lines = NULL;
   answer_json->GetList("l", &lines);
   if (!lines || lines->GetSize() == 0)
     return;
 
   for (size_t line = 0; line < lines->GetSize(); ++line) {
     const base::DictionaryValue* imageLine = NULL;
     lines->GetDictionary(line, &imageLine);
     if (!imageLine)
       continue;
     const base::DictionaryValue* imageData = NULL;
     imageLine->GetDictionary("i", &imageData);
     if (!imageData)
       continue;
     std::string imageUrl;
     imageData->GetString("d", &imageUrl);
-    image_prefetch_callback.Run(GURL(imageUrl));
+    urls->push_back(GURL(imageUrl));
   }
 }