Store xsrf token received with psuggest results.

chrome/browser/autocomplete/search_provider.cc

 // Copyright 2012 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/search_provider.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/callback.h"
@@ skipping 191 matching lines @@
 }
 
 
 // SearchProvider::SuggestResult ----------------------------------------------
 
 SearchProvider::SuggestResult::SuggestResult(
     const string16& suggestion,
     const string16& match_contents,
     const string16& annotation,
     const std::string& suggest_query_params,
+    const std::string& xsrf_token,
     bool from_keyword_provider,
     int relevance,
     bool relevance_from_server,
     bool should_prefetch)
     : Result(from_keyword_provider, relevance, relevance_from_server),
       suggestion_(suggestion),
       match_contents_(match_contents),
       annotation_(annotation),
       suggest_query_params_(suggest_query_params),
+      xsrf_token_(xsrf_token),
       should_prefetch_(should_prefetch) {
 }
 
 SearchProvider::SuggestResult::~SuggestResult() {
 }
 
 bool SearchProvider::SuggestResult::IsInlineable(const string16& input) const {
   return StartsWith(suggestion_, input, false);
 }
 
@@ skipping 114 matching lines @@
     const AutocompleteInput& input,
     const string16& input_text,
     int relevance,
     AutocompleteMatch::Type type,
     bool is_keyword,
     const string16& match_contents,
     const string16& annotation,
     const TemplateURL* template_url,
     const string16& query_string,
     const std::string& suggest_query_params,
+    const std::string& xsrf_token,
     int accepted_suggestion,
     int omnibox_start_margin,
     bool append_extra_query_params) {
   AutocompleteMatch match(autocomplete_provider, relevance, false, type);
 
   if (!template_url)
     return match;
   match.keyword = template_url->keyword();
 
   SetAndClassifyMatchContents(
@@ skipping 18 matching lines @@
   const TemplateURLRef& search_url = template_url->url_ref();
   DCHECK(search_url.SupportsReplacement());
   match.search_terms_args.reset(
       new TemplateURLRef::SearchTermsArgs(query_string));
   match.search_terms_args->original_query = input_text;
   match.search_terms_args->accepted_suggestion = accepted_suggestion;
   match.search_terms_args->omnibox_start_margin = omnibox_start_margin;
   match.search_terms_args->suggest_query_params = suggest_query_params;
   match.search_terms_args->append_extra_query_params =
       append_extra_query_params;
+  match.search_terms_args->xsrf_token = xsrf_token;
   // This is the destination URL sans assisted query stats.  This must be set
   // so the AutocompleteController can properly de-dupe; the controller will
   // eventually overwrite it before it reaches the user.
   match.destination_url =
       GURL(search_url.ReplaceSearchTerms(*match.search_terms_args.get()));
 
   // Search results don't look like URLs.
   match.transition = is_keyword ?
       content::PAGE_TRANSITION_KEYWORD : content::PAGE_TRANSITION_GENERATED;
 
@@ skipping 632 matching lines @@
         results->navigation_results.push_back(NavigationResult(
             *this, url, title, is_keyword, relevance, true));
       }
     } else {
       bool should_prefetch = static_cast<int>(index) == prefetch_index;
       DictionaryValue* suggestion_detail = NULL;
       string16 match_contents = suggestion;
       string16 disambiguating_query;
       string16 annotation;
       std::string suggest_query_params;
+      std::string xsrf_token;
       if (suggestion_details && (type == "ENTITY") &&
           suggestion_details->GetDictionary(index, &suggestion_detail) &&
           suggestion_detail) {
         suggestion_detail->GetString("a", &annotation);
         if (suggestion_detail->GetString("dq", &disambiguating_query) &&
             !disambiguating_query.empty())
           suggestion = disambiguating_query;
         suggestion_detail->GetString("q", &suggest_query_params);
+      } else if (suggestion_details && (type == "PERSONALIZED_QUERY") &&
+          suggestion_details->GetDictionary(index, &suggestion_detail) &&
+          suggestion_detail) {
+        suggestion_detail->GetString("x", &xsrf_token);
       }
       // TODO(kochi): Improve calculator suggestion presentation.
       results->suggest_results.push_back(SuggestResult(
           suggestion, match_contents, annotation, suggest_query_params,
-          is_keyword, relevance, true, should_prefetch));
+          xsrf_token, is_keyword, relevance, true, should_prefetch));
     }
   }
 
   // Apply calculated relevance scores if a valid list was not provided.
   if (relevances == NULL) {
     ApplyCalculatedSuggestRelevance(&results->suggest_results);
     ApplyCalculatedNavigationRelevance(&results->navigation_results);
   }
   // Keep the result lists sorted.
   const CompareScoredResults comparator = CompareScoredResults();
@@ skipping 29 matching lines @@
                   relevance_from_server,
                   false,
                   std::string(),
                   AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
                   false,
                   input_.text(),
                   string16(),
                   input_.text(),
                   did_not_accept_default_suggestion,
                   std::string(),
+                  std::string(),
                   &map);
   }
   if (!keyword_input_.text().empty()) {
     const TemplateURL* keyword_url = providers_.GetKeywordProviderURL();
     // We only create the verbatim search query match for a keyword
     // if it's not an extension keyword.  Extension keywords are handled
     // in KeywordProvider::Start().  (Extensions are complicated...)
     // Note: in this provider, SEARCH_OTHER_ENGINE must correspond
     // to the keyword verbatim search query.  Do not create other matches
     // of type SEARCH_OTHER_ENGINE.
     if (keyword_url &&
         (keyword_url->GetType() != TemplateURL::OMNIBOX_API_EXTENSION)) {
       bool keyword_relevance_from_server;
       const int keyword_verbatim_relevance =
           GetKeywordVerbatimRelevance(&keyword_relevance_from_server);
       if (keyword_verbatim_relevance > 0) {
         AddMatchToMap(keyword_input_.text(),
                       keyword_verbatim_relevance,
                       keyword_relevance_from_server,
                       false,
                       std::string(),
                       AutocompleteMatchType::SEARCH_OTHER_ENGINE,
                       true,
                       keyword_input_.text(),
                       string16(),
                       keyword_input_.text(),
                       did_not_accept_keyword_suggestion,
                       std::string(),
+                      std::string(),
                       &map);
       }
     }
   }
   AddHistoryResultsToMap(keyword_history_results_, true,
                          did_not_accept_keyword_suggestion, &map);
   AddHistoryResultsToMap(default_history_results_, false,
                          did_not_accept_default_suggestion, &map);
 
   AddSuggestResultsToMap(keyword_results_.suggest_results,
@@ skipping 228 matching lines @@
                   false,
                   false,
                   std::string(),
                   AutocompleteMatchType::SEARCH_HISTORY,
                   is_keyword,
                   i->suggestion(),
                   string16(),
                   i->suggestion(),
                   did_not_accept_suggestion,
                   std::string(),
+                  std::string(),
                   map);
   }
   UMA_HISTOGRAM_TIMES("Omnibox.SearchProvider.AddHistoryResultsTime",
                       base::TimeTicks::Now() - start_time);
 }
 
 SearchProvider::SuggestResults SearchProvider::ScoreHistoryResults(
     const HistoryResults& results,
     bool base_prevent_inline_autocomplete,
     bool input_multiple_words,
@@ skipping 30 matching lines @@
       classifier->Classify(i->term, false, false, &match, NULL);
       prevent_inline_autocomplete =
           !AutocompleteMatch::IsSearchType(match.type);
     }
 
     int relevance = CalculateRelevanceForHistory(
         i->time, is_keyword, !prevent_inline_autocomplete,
         prevent_search_history_inlining);
     scored_results.push_back(
         SuggestResult(i->term, string16(), string16(), std::string(),
-                      is_keyword, relevance, false, false));
+                      std::string(), is_keyword, relevance, false, false));
   }
 
   // History returns results sorted for us.  However, we may have docked some
   // results' scores, so things are no longer in order.  Do a stable sort to get
   // things back in order without otherwise disturbing results with equal
   // scores, then force the scores to be unique, so that the order in which
   // they're shown is deterministic.
   std::stable_sort(scored_results.begin(), scored_results.end(),
                    CompareScoredResults());
   int last_relevance = 0;
@@ skipping 18 matching lines @@
                   results[i].relevance_from_server(),
                   results[i].should_prefetch(),
                   metadata,
                   AutocompleteMatchType::SEARCH_SUGGEST,
                   is_keyword,
                   results[i].match_contents(),
                   results[i].annotation(),
                   results[i].suggestion(),
                   i,
                   results[i].suggest_query_params(),
+                  results[i].xsrf_token(),
                   map);
   }
 }
 
 int SearchProvider::GetVerbatimRelevance(bool* relevance_from_server) const {
   // Use the suggested verbatim relevance score if it is non-negative (valid),
   // if inline autocomplete isn't prevented (always show verbatim on backspace),
   // and if it won't suppress verbatim, leaving no default provider matches.
   // Otherwise, if the default provider returned no matches and was still able
   // to suppress verbatim, the user would have no search/nav matches and may be
@@ skipping 104 matching lines @@
                                    bool relevance_from_server,
                                    bool should_prefetch,
                                    const std::string& metadata,
                                    AutocompleteMatch::Type type,
                                    bool is_keyword,
                                    const string16& match_contents,
                                    const string16& annotation,
                                    const string16& query_string,
                                    int accepted_suggestion,
                                    const std::string& suggest_query_params,
+                                   const std::string& xsrf_token,
                                    MatchMap* map) {
   // On non-mobile, ask the instant controller for the appropriate start margin.
   // On mobile the start margin is unused, so leave the value as default there.
   int omnibox_start_margin = chrome::kDisableStartMargin;
 #if !defined(OS_ANDROID) && !defined(IOS)
   if (chrome::IsInstantExtendedAPIEnabled()) {
     Browser* browser =
         chrome::FindBrowserWithProfile(profile_, chrome::GetActiveDesktop());
     if (browser && browser->instant_controller() &&
         browser->instant_controller()->instant()) {
       omnibox_start_margin =
           browser->instant_controller()->instant()->omnibox_bounds().x();
     }
   }
 #endif  // !defined(OS_ANDROID) && !defined(IOS)
 
   const TemplateURL* template_url = is_keyword ?
       providers_.GetKeywordProviderURL() : providers_.GetDefaultProviderURL();
   AutocompleteMatch match = CreateSearchSuggestion(
       this, input_, input_text, relevance, type, is_keyword, match_contents,
       annotation, template_url, query_string, suggest_query_params,
-      accepted_suggestion, omnibox_start_margin,
+      xsrf_token, accepted_suggestion, omnibox_start_margin,
       !is_keyword || providers_.default_provider().empty());
   if (!match.destination_url.is_valid())
     return;
   match.search_terms_args->bookmark_bar_pinned =
       profile_->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar);
   match.RecordAdditionalInfo(kRelevanceFromServerKey,
                              relevance_from_server ? kTrue : kFalse);
   match.RecordAdditionalInfo(kShouldPrefetchKey,
                              should_prefetch ? kTrue : kFalse);
 
@@ skipping 151 matching lines @@
     it->set_relevance(max_query_relevance);
     it->set_relevance_from_server(relevance_from_server);
   }
 }
 
 void SearchProvider::UpdateDone() {
   // We're done when the timer isn't running, there are no suggest queries
   // pending, and we're not waiting on Instant.
   done_ = !timer_.IsRunning() && (suggest_results_pending_ == 0);
 }