[AiS] Use top local result for prefetch.

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/base64.h"
@@ skipping 227 matching lines @@
       match.allowed_to_be_default_match = true;
       matches_.push_back(match);
     }
     Stop(true);
     return;
   }
 
   input_ = input;
 
   DoHistoryQuery(minimal_changes);
+  // Answers needs the scored history results before any suggest query has been
+  // started.
+  if (OmniboxFieldTrial::EnableAnswersInSuggest()) {

[groby-ooo-7-16, 2014/08/22 23:09:56]

Do we want a UMA histogram for the time spent here?

+    scored_default_history_results_.clear();
+    scored_keyword_history_results_.clear();
+    ScoreHistoryResultsMultiWord(
+        default_history_results_, false, &scored_default_history_results_);
+    ScoreHistoryResultsMultiWord(
+        keyword_history_results_, true, &scored_keyword_history_results_);
+  }
   DoAnswersQuery(input);
   StartOrStopSuggestQuery(minimal_changes);
   UpdateMatches();
 }
 
 void SearchProvider::Stop(bool clear_cached_results) {
   StopSuggest();
   done_ = true;
 
   if (clear_cached_results)
@@ skipping 608 matching lines @@
 }
 
 void SearchProvider::AddHistoryResultsToMap(const HistoryResults& results,
                                             bool is_keyword,
                                             int did_not_accept_suggestion,
                                             MatchMap* map) {
   if (results.empty())
     return;
 
   base::TimeTicks start_time(base::TimeTicks::Now());
-  bool prevent_inline_autocomplete = input_.prevent_inline_autocomplete() ||
-      (input_.type() == metrics::OmniboxInputType::URL);
-  const base::string16& input_text =
-      is_keyword ? keyword_input_.text() : input_.text();
-  bool input_multiple_words = HasMultipleWords(input_text);
 
-  SearchSuggestionParser::SuggestResults scored_results;
-  if (!prevent_inline_autocomplete && input_multiple_words) {
-    // ScoreHistoryResults() allows autocompletion of multi-word, 1-visit
-    // queries if the input also has multiple words.  But if we were already
-    // scoring a multi-word, multi-visit query aggressively, and the current
-    // input is still a prefix of it, then changing the suggestion suddenly
-    // feels wrong.  To detect this case, first score as if only one word has
-    // been typed, then check if the best result came from aggressive search
-    // history scoring.  If it did, then just keep that score set.  This
-    // 1200 the lowest possible score in CalculateRelevanceForHistory()'s
-    // aggressive-scoring curve.
-    scored_results = ScoreHistoryResults(results, prevent_inline_autocomplete,
-                                         false, input_text, is_keyword);
-    if ((scored_results.front().relevance() < 1200) ||
-        !HasMultipleWords(scored_results.front().suggestion()))
-      scored_results.clear();  // Didn't detect the case above, score normally.
+  // Until Answers becomes default, scoring of history results will still happen
+  // here for non-Answers Chrome, to prevent any impact on timing measurements.
+  // Answers FieldTrials will instead use scoring results obtained previously.
+  SearchSuggestionParser::SuggestResults local_scored_results;
+  const SearchSuggestionParser::SuggestResults* scored_results = NULL;
+  if (!OmniboxFieldTrial::EnableAnswersInSuggest()) {

[groby-ooo-7-16, 2014/08/22 23:09:56]

Since scoring can now take two different paths - should we exercise both paths
in the unit tests?

For my own reference, here's the list of tests that touch this code path:
SearchProviderTest.QueryDefaultProvider
SearchProviderTest.HonorPreventInlineAutocomplete
SearchProviderTest.QueryKeywordProvider
SearchProviderTest.DontAutocompleteURLLikeTerms
SearchProviderTest.DontAutocompleteUntilMultipleWordsTyped
SearchProviderTest.AutocompleteMultipleVisitsImmediately
SearchProviderTest.AutocompleteAfterSpace
SearchProviderTest.ScoreNewerSearchesHigher
SearchProviderTest.DontReplacePreviousAutocompletion
SearchProviderTest.DontCrowdOutSingleWords
SearchProviderTest.InlineMixedCaseMatches
SearchProviderTest.KeywordOrderingAndDescriptions
SearchProviderTest.LocalAndRemoteRelevances
SearchProviderTest.ReflectsBookmarkBarState
SearchProviderTest.TestDeleteHistoryQueryMatch
SearchProviderTest.CheckDuplicateMatchesSaved

+    ScoreHistoryResultsMultiWord(results, is_keyword, &local_scored_results);
+    scored_results = &local_scored_results;
+  } else {
+    scored_results = is_keyword ? &scored_keyword_history_results_
+                                : &scored_default_history_results_;
   }
-  if (scored_results.empty())
-    scored_results = ScoreHistoryResults(results, prevent_inline_autocomplete,
-                                         input_multiple_words, input_text,
-                                         is_keyword);
+  DCHECK(scored_results);
+
   for (SearchSuggestionParser::SuggestResults::const_iterator i(
-           scored_results.begin()); i != scored_results.end(); ++i) {
+           scored_results->begin()); i != scored_results->end(); ++i) {
     AddMatchToMap(*i, std::string(), did_not_accept_suggestion, true,
                   providers_.GetKeywordProviderURL() != NULL, map);
   }
   UMA_HISTOGRAM_TIMES("Omnibox.SearchProvider.AddHistoryResultsTime",
                       base::TimeTicks::Now() - start_time);
 }
 
 SearchSuggestionParser::SuggestResults SearchProvider::ScoreHistoryResults(
     const HistoryResults& results,
     bool base_prevent_inline_autocomplete,
@@ skipping 99 matching lines @@
   for (SearchSuggestionParser::SuggestResults::iterator i(
            scored_results.begin()); i != scored_results.end(); ++i) {
     if ((last_relevance != 0) && (i->relevance() >= last_relevance))
       i->set_relevance(last_relevance - 1);
     last_relevance = i->relevance();
   }
 
   return scored_results;
 }
 
+void SearchProvider::ScoreHistoryResultsMultiWord(
+    const HistoryResults& results,
+    bool is_keyword,
+    SearchSuggestionParser::SuggestResults* scored_results) {
+  bool prevent_inline_autocomplete =
+      input_.prevent_inline_autocomplete() ||
+      (input_.type() == metrics::OmniboxInputType::URL);
+  const base::string16& input_text =
+      is_keyword ? keyword_input_.text() : input_.text();
+  bool input_multiple_words = HasMultipleWords(input_text);
+
+  if (!prevent_inline_autocomplete && input_multiple_words) {
+    // ScoreHistoryResults() allows autocompletion of multi-word, 1-visit
+    // queries if the input also has multiple words.  But if we were already
+    // scoring a multi-word, multi-visit query aggressively, and the current
+    // input is still a prefix of it, then changing the suggestion suddenly
+    // feels wrong.  To detect this case, first score as if only one word has
+    // been typed, then check if the best result came from aggressive search
+    // history scoring.  If it did, then just keep that score set.  This
+    // 1200 the lowest possible score in CalculateRelevanceForHistory()'s
+    // aggressive-scoring curve.
+    *scored_results = ScoreHistoryResults(
+        results, prevent_inline_autocomplete, false, input_text, is_keyword);
+    if ((scored_results->front().relevance() < 1200) ||
+        !HasMultipleWords(scored_results->front().suggestion()))
+      scored_results->clear();  // Didn't detect the case above, score normally.
+  }
+  if (scored_results->empty())
+    *scored_results = ScoreHistoryResults(results, prevent_inline_autocomplete,
+                                          input_multiple_words, input_text,
+                                          is_keyword);
+}
+
 void SearchProvider::AddSuggestResultsToMap(
     const SearchSuggestionParser::SuggestResults& results,
     const std::string& metadata,
     MatchMap* map) {
   for (size_t i = 0; i < results.size(); ++i) {
     AddMatchToMap(results[i], metadata, i, false,
                   providers_.GetKeywordProviderURL() != NULL, map);
   }
 }
 
@@ skipping 226 matching lines @@
   last_answer_seen_.query_type = match->answer_type;
 }
 
 void SearchProvider::DoAnswersQuery(const AutocompleteInput& input) {
   // If the query text starts with trimmed input, this is valid prefetch data.
   prefetch_data_ = StartsWith(last_answer_seen_.full_query_text,
                               base::CollapseWhitespace(input.text(), false),
                               false) ?
       last_answer_seen_ : AnswersQueryData();
 }