Omnibox: Make the Controller Reorder Matches for Inlining

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 237 matching lines @@
     : AutocompleteProvider(listener, profile,
           AutocompleteProvider::TYPE_SEARCH),
       providers_(TemplateURLServiceFactory::GetForProfile(profile)),
       suggest_results_pending_(0),
       field_trial_triggered_(false),
       field_trial_triggered_in_session_(false),
       omnibox_start_margin_(-1),
       prevent_search_history_inlining_(
           OmniboxFieldTrial::SearchHistoryPreventInlining()),
       disable_search_history_(
-          OmniboxFieldTrial::SearchHistoryDisable()) {
+          OmniboxFieldTrial::SearchHistoryDisable()),
+      omnibox_will_reorder_for_legal_default_match_(
+          OmniboxFieldTrial::InReorderForLegalDefaultMatchGroup()) {
 }
 
 // static
 AutocompleteMatch SearchProvider::CreateSearchSuggestion(
     AutocompleteProvider* autocomplete_provider,
     int relevance,
     AutocompleteMatch::Type type,
     const TemplateURL* template_url,
     const string16& query_string,
     const string16& input_text,
@@ skipping 39 matching lines @@
         match.contents_class.push_back(
             ACMatchClassification(next_fragment_position,
                                   ACMatchClassification::MATCH));
       }
     }
   } else {
     // Otherwise, we're dealing with the "default search" result which has no
     // completion.
     match.contents_class.push_back(
         ACMatchClassification(0, ACMatchClassification::NONE));
+    match.allowed_to_be_default_match = true;
   }
 
   // When the user forced a query, we need to make sure all the fill_into_edit
   // values preserve that property.  Otherwise, if the user starts editing a
   // suggestion, non-Search results will suddenly appear.
   if (input.type() == AutocompleteInput::FORCED_QUERY)
     match.fill_into_edit.assign(ASCIIToUTF16("?"));
   if (is_keyword)
     match.fill_into_edit.append(match.keyword + char16(' '));
   if (!input.prevent_inline_autocomplete() &&
       StartsWith(query_string, input_text, false)) {
     match.inline_autocomplete_offset =
         match.fill_into_edit.length() + input_text.length();
+    match.allowed_to_be_default_match = true;
   }
   match.fill_into_edit.append(query_string);
 
   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;
@@ skipping 724 matching lines @@
 
 bool SearchProvider::IsTopMatchHighRankSearchForURL() const {
   return input_.type() == AutocompleteInput::URL &&
          matches_.front().relevance > CalculateRelevanceForVerbatim() &&
          (matches_.front().type == AutocompleteMatchType::SEARCH_SUGGEST ||
           matches_.front().type ==
               AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED ||
           matches_.front().type == AutocompleteMatchType::SEARCH_OTHER_ENGINE);
 }
 
-bool SearchProvider::IsTopMatchNotInlinable() const {
-  // Note: this test assumes the SEARCH_OTHER_ENGINE match corresponds to
-  // the verbatim search query on the keyword engine.  SearchProvider should
-  // not create any other match of type SEARCH_OTHER_ENGINE.
-  return
-      matches_.front().type != AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED &&
-      matches_.front().type != AutocompleteMatchType::SEARCH_OTHER_ENGINE &&
-      matches_.front().inline_autocomplete_offset == string16::npos &&
-      matches_.front().fill_into_edit != input_.text();
+bool SearchProvider::IsTopMatchNotAllowedToBeDefaultMatch() const {
+  return !matches_.front().allowed_to_be_default_match;
+}
+
+bool SearchProvider::LacksDefaultMatch() const {
+  for (ACMatches::const_iterator it = matches_.begin(); it != matches_.end();
+       ++it) {
+    if (it->allowed_to_be_default_match)
+      return false;
+  }
+  return true;
 }
 
 void SearchProvider::UpdateMatches() {
   ConvertResultsToAutocompleteMatches();
 
   // Check constraints that may be violated by suggested relevances.
   if (!matches_.empty() &&
       (default_results_.HasServerProvidedScores() ||
        keyword_results_.HasServerProvidedScores())) {
     // These blocks attempt to repair undesirable behavior by suggested
@@ skipping 24 matching lines @@
       // Disregard the suggested search and verbatim relevances if the input
       // type is URL and the top match is a highly-ranked search suggestion.
       // For example, prevent a search for "foo.com" from outranking another
       // provider's navigation for "foo.com" or "foo.com/url_from_history".
       ApplyCalculatedSuggestRelevance(&keyword_results_.suggest_results);
       ApplyCalculatedSuggestRelevance(&default_results_.suggest_results);
       default_results_.verbatim_relevance = -1;
       keyword_results_.verbatim_relevance = -1;
       ConvertResultsToAutocompleteMatches();
     }
-    if (IsTopMatchNotInlinable()) {
-      // Disregard suggested relevances if the top match is not a verbatim match
-      // or inlinable.  For example, input "foo" should not invoke a search for
-      // "bar", which would happen if the "bar" search match outranked all other
-      // matches.
+    if ((!omnibox_will_reorder_for_legal_default_match_ &&

[Peter Kasting, 2013/07/17 18:29:48]

Nit: Simpler:

    if (omnibox_will_reorder_for_legal_default_match_ ?
        LacksDefaultMatch() : IsTopMatchNotAllowedToBeDefaultMatch())

[Mark P, 2013/07/17 20:39:18]

Done.

+         IsTopMatchNotAllowedToBeDefaultMatch()) ||
+        (omnibox_will_reorder_for_legal_default_match_ &&
+         LacksDefaultMatch())) {
+      // Disregard suggested relevances if either:
+      // * the top match is not allowed to be the default match (i.e., it's not
+      //   either a verbatim match or inlinable).  For example, input "foo"
+      //   should not invoke a search for "bar", which would happen if the
+      //   "bar" search match outranked all other matches.  We only care
+      //   about this condition if the omnibox itself will not reorder
+      //   matches to put a legal default match on top.
+      // * no matches are allowed to be the default match.  SearchProvider is
+      //   supposed to return a legal default match for any input.  We need
+      //   to make sure it does so.  This constraint should be true always,
+      //   but we only need to check it if
+      //   |omnibox_will_reorder_for_legal_default_match_|.  (If that were
+      //   false, the first part of the test above will suffice.)
       ApplyCalculatedRelevance();
       ConvertResultsToAutocompleteMatches();
     }
     DCHECK(!IsTopMatchNavigationInKeywordMode());
     DCHECK(!IsTopMatchScoreTooLow());
     DCHECK(!IsTopMatchHighRankSearchForURL());
-    DCHECK(!IsTopMatchNotInlinable());
+    DCHECK(omnibox_will_reorder_for_legal_default_match_ ||
+           !IsTopMatchNotAllowedToBeDefaultMatch());
+    DCHECK(!LacksDefaultMatch());
   }
 
   UpdateStarredStateOfMatches();
   UpdateDone();
 }
 
 void SearchProvider::AddNavigationResultsToMatches(
     const NavigationResults& navigation_results,
     ACMatches* matches) {
   for (NavigationResults::const_iterator it = navigation_results.begin();
@@ skipping 366 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);
 }