Omnibox: Make HUP Scoring More Sane in Prevent-Inline Mode

chrome/browser/autocomplete/history_url_provider.cc

 // Copyright (c) 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/history_url_provider.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 550 matching lines @@
   // url_db can be NULL if it hasn't finished initializing (or failed to
   // initialize).  In this case all we can do is fall back on the second
   // pass.
   //
   // TODO(pkasting): We should just block here until this loads.  Any time
   // someone unloads the history backend, we'll get inconsistent inline
   // autocomplete behavior here.
   if (url_db) {
     DoAutocomplete(NULL, url_db, params.get());
     matches_.clear();
-    PromoteMatchIfNecessary(*params);
+    PromoteMatchesIfNecessary(*params);
     // NOTE: We don't reset |params| here since at least the |promote_type|
     // field on it will be read by the second pass -- see comments in
     // DoAutocomplete().
   }
 
   // Pass 2: Ask the history service to call us back on the history thread,
   // where we can read the full on-disk DB.
   if (input.want_asynchronous_matches()) {
     done_ = false;
     params_ = params.release();  // This object will be destroyed in
@@ skipping 177 matching lines @@
   SortAndDedupMatches(&params->matches);
 
   // Try to create a shorter suggestion from the best match.
   // We consider the what you typed match eligible for display when it's
   // navigable and there's a reasonable chance the user intended to do
   // something other than search.  We use a variety of heuristics to determine
   // this, e.g. whether the user explicitly typed a scheme, or if omnibox
   // searching has been disabled by policy. In the cases where we've parsed as
   // UNKNOWN, we'll still show an accidental search infobar if need be.
   VisitClassifier classifier(this, params->input, db);
-  bool have_what_you_typed_match =
+  params->have_what_you_typed_match =
       (params->input.type() != metrics::OmniboxInputType::QUERY) &&
       ((params->input.type() != metrics::OmniboxInputType::UNKNOWN) ||
        (classifier.type() == VisitClassifier::UNVISITED_INTRANET) ||
        !params->trim_http ||
        (AutocompleteInput::NumNonHostComponents(params->input.parts()) > 0) ||
        !params->default_search_provider);
   const bool have_shorter_suggestion_suitable_for_inline_autocomplete =
-      PromoteOrCreateShorterSuggestion(db, have_what_you_typed_match, params);
+      PromoteOrCreateShorterSuggestion(
+          db, params->have_what_you_typed_match, params);

[Peter Kasting, 2015/03/20 23:30:19]

Just have this function read |have_what_you_typed_match| from |params|.

[Mark P, 2015/03/24 18:23:26]

Silly me for overlooking this.  Done.

 
   // Check whether what the user typed appears in history.
   const bool can_check_history_for_exact_match =
       // Checking what_you_typed_match.is_history_what_you_typed_match tells us
       // whether SuggestExactInput() succeeded in constructing a valid match.
       params->what_you_typed_match.is_history_what_you_typed_match &&
       // Additionally, in the case where the user has typed "foo.com" and
       // visited (but not typed) "foo/", and the input is "foo", the first pass
       // will fall into the FRONT_HISTORY_MATCH case for "foo.com" but the
       // second pass can suggest the exact input as a better URL.  Since we need
       // both passes to agree, and since during the first pass there's no way to
       // know about "foo/", ensure that if the promote type was set to
       // FRONT_HISTORY_MATCH during the first pass, the second pass will not
       // consider the exact suggestion to be in history and therefore will not
       // suggest the exact input as a better match.  (Note that during the first
       // pass, this conditional will always succeed since |promote_type| is
       // initialized to NEITHER.)
       (params->promote_type != HistoryURLProviderParams::FRONT_HISTORY_MATCH);
   params->exact_suggestion_is_in_history = can_check_history_for_exact_match &&
       FixupExactSuggestion(db, classifier, params);
 
   // If we succeeded in fixing up the exact match based on the user's history,
   // we should treat it as the best match regardless of input type.  If not,
   // then we check whether there's an inline autocompletion we can create from
   // this input, so we can promote that as the best match.
   if (params->exact_suggestion_is_in_history) {
     params->promote_type = HistoryURLProviderParams::WHAT_YOU_TYPED_MATCH;
-  } else if (!params->prevent_inline_autocomplete && !params->matches.empty() &&
-      (have_shorter_suggestion_suitable_for_inline_autocomplete ||
-       CanPromoteMatchForInlineAutocomplete(params->matches[0]))) {
+  } else if (!params->matches.empty() &&
+             (have_shorter_suggestion_suitable_for_inline_autocomplete ||
+              CanPromoteMatchForInlineAutocomplete(params->matches[0]))) {
     params->promote_type = HistoryURLProviderParams::FRONT_HISTORY_MATCH;
   } else {
     // Failed to promote any URLs.  Use the What You Typed match, if we have it.
-    params->promote_type = have_what_you_typed_match ?
+    params->promote_type = params->have_what_you_typed_match ?
         HistoryURLProviderParams::WHAT_YOU_TYPED_MATCH :
         HistoryURLProviderParams::NEITHER;
   }
 
   const size_t max_results =
       kMaxMatches + (params->exact_suggestion_is_in_history ? 1 : 0);
   if (backend) {
     // Remove redirects and trim list to size.  We want to provide up to
     // kMaxMatches results plus the What You Typed result, if it was added to
     // params->matches above.
     CullRedirects(backend, &params->matches, max_results);
   } else if (params->matches.size() > max_results) {
     // Simply trim the list to size.
     params->matches.resize(max_results);
   }
 }
 
-void HistoryURLProvider::PromoteMatchIfNecessary(
+void HistoryURLProvider::PromoteMatchesIfNecessary(
     const HistoryURLProviderParams& params) {
   if (params.promote_type == HistoryURLProviderParams::NEITHER)
     return;
-  matches_.push_back(
-      (params.promote_type == HistoryURLProviderParams::WHAT_YOU_TYPED_MATCH) ?
-      params.what_you_typed_match :
-      HistoryMatchToACMatch(params, 0, INLINE_AUTOCOMPLETE,
-                            CalculateRelevance(INLINE_AUTOCOMPLETE, 0)));
+  if (params.promote_type == HistoryURLProviderParams::FRONT_HISTORY_MATCH) {
+    matches_.push_back(
+        HistoryMatchToACMatch(params, 0, INLINE_AUTOCOMPLETE,
+                              CalculateRelevance(INLINE_AUTOCOMPLETE, 0)));
+  }
+  // Add the what-you-typed match if you we're explicitly told to or if we need

[Peter Kasting, 2015/03/20 23:30:19]

Nit: "you"?

[Mark P, 2015/03/24 18:23:26]

Fixed.

+  // it because we added an inline-autocomplete match yet inline autocompletion
+  // is disabled (so it will not be allowed to be the default match).  Hence,
+  // we need to add the what-you-typed match as a legal default match.
+  if ((params.promote_type == HistoryURLProviderParams::WHAT_YOU_TYPED_MATCH) ||
+      (params.prevent_inline_autocomplete &&
+       params.have_what_you_typed_match)) {

[Peter Kasting, 2015/03/20 23:30:19]

Won't this always add the WYT match for |prevent_inline_autocomplete|, even if
we didn't add anything else?

[Mark P, 2015/03/24 18:23:26]

Yes, it'll always add a WYT match for |prevent_inline_autocomplete| if we have
one we're willing to display (|have_what_you_typed_match|).  Revised comment.

[Peter Kasting, 2015/03/24 21:05:39]

Huh.  I'm wondering if that's a potential quality loss.  It seems like in cases
where we didn't previously add this (because it's a poor match), and we haven't
added an inline-autocomplete match we need to outscore, we still shouldn't be
adding this.

Or am I missing a case this will break?

[Mark P, 2015/03/24 21:40:50]

Are you suggesting adding an && !matches.empty() to the second half of the test?

I don't think that'll change anything.

If we don't have a result that we promote to inline autocompletion, we always
add the WYT match if it's eligible (|params.have_what_you_typed_match|).  See
lines 806-815 in this file.

In other words, if all we have are low-quality matches, we always add the WYT
match if it's eligible.  Please tell me if I'm reading the code wrong.  This new
patch will keep this behavior.

+    matches_.push_back(params.what_you_typed_match);
+  }
 }
 
 void HistoryURLProvider::QueryComplete(
     HistoryURLProviderParams* params_gets_deleted) {
   // Ensure |params_gets_deleted| gets deleted on exit.
   scoped_ptr<HistoryURLProviderParams> params(params_gets_deleted);
 
   // If the user hasn't already started another query, clear our member pointer
   // so we can't write into deleted memory.
   if (params_ == params_gets_deleted)
     params_ = NULL;
 
   // Don't send responses for queries that have been canceled.
   if (params->cancel_flag.IsSet())
     return;  // Already set done_ when we canceled, no need to set it again.
 
   // Don't modify |matches_| if the query failed, since it might have a default
   // match in it, whereas |params->matches| will be empty.
   if (!params->failed) {
     matches_.clear();
-    PromoteMatchIfNecessary(*params);
+    PromoteMatchesIfNecessary(*params);
 
     // Determine relevance of highest scoring match, if any.
     int relevance = matches_.empty() ?
         CalculateRelevance(NORMAL,
                            static_cast<int>(params->matches.size() - 1)) :
         matches_[0].relevance;
 
     // Convert the history matches to autocomplete matches.  If we promoted the
     // first match, skip over it.
     const size_t first_match =
@@ skipping 284 matching lines @@
     AutocompleteMatch::ClassifyLocationInString(base::string16::npos, 0,
         match.contents.length(), ACMatchClassification::URL,
         &match.contents_class);
   }
   match.description = info.title();
   match.description_class =
       ClassifyDescription(params.input.text(), match.description);
   RecordAdditionalInfoFromUrlRow(info, &match);
   return match;
 }