Omnibox: Create Keyword Verbatim Result in Search Provider

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 765 matching lines @@
 }
 
 void SearchProvider::ConvertResultsToAutocompleteMatches() {
   // Convert all the results to matches and add them to a map, so we can keep
   // the most relevant match for each result.
   MatchMap map;
   const Time no_time;
   int did_not_accept_keyword_suggestion = keyword_suggest_results_.empty() ?
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE :
       TemplateURLRef::NO_SUGGESTION_CHOSEN;
-  // Keyword what you typed results are handled by the KeywordProvider.
 
   int verbatim_relevance = GetVerbatimRelevance();
   int did_not_accept_default_suggestion = default_suggest_results_.empty() ?
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE :
       TemplateURLRef::NO_SUGGESTION_CHOSEN;
   if (verbatim_relevance > 0) {
     AddMatchToMap(input_.text(), input_.text(), verbatim_relevance,
                   AutocompleteMatch::SEARCH_WHAT_YOU_TYPED,
                   did_not_accept_default_suggestion, false, &map);
   }
-  const size_t what_you_typed_size = map.size();
+  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->IsExtensionKeyword()) {
+      AddMatchToMap(keyword_input_text_, keyword_input_text_,
+                    CalculateRelevanceForKeywordVerbatim(
+                        input_.type(), input_.prefer_keyword()),
+                    AutocompleteMatch::SEARCH_OTHER_ENGINE,
+                    did_not_accept_keyword_suggestion, true, &map);
+    }
+  }
+  const size_t verbatim_matches_size = map.size();
   if (!default_provider_suggestion_.text.empty() &&
       default_provider_suggestion_.type == INSTANT_SUGGESTION_SEARCH &&
       !input_.prevent_inline_autocomplete())
     AddMatchToMap(input_.text() + default_provider_suggestion_.text,
                   input_.text(), verbatim_relevance + 1,
                   AutocompleteMatch::SEARCH_SUGGEST,
                   did_not_accept_default_suggestion, false, &map);
 
   AddHistoryResultsToMap(keyword_history_results_, true,
                          did_not_accept_keyword_suggestion, &map);
@@ skipping 15 matching lines @@
     // |verbatim_relevance| here.
     matches_.push_back(NavigationToMatch(
         NavigationResult(GURL(UTF16ToUTF8(default_provider_suggestion_.text)),
                          string16(),
                          kNonURLVerbatimRelevance + 1),
         false));
   }
   AddNavigationResultsToMatches(keyword_navigation_results_, true);
   AddNavigationResultsToMatches(default_navigation_results_, false);
 
-  // Allow an additional match for "what you typed" if it's present.
-  const size_t max_total_matches = kMaxMatches + what_you_typed_size;
+  // Allow additional match(es) for verbatim results if present.
+  const size_t max_total_matches = kMaxMatches + verbatim_matches_size;
   std::partial_sort(matches_.begin(),
       matches_.begin() + std::min(max_total_matches, matches_.size()),
       matches_.end(), &AutocompleteMatch::MoreRelevant);
 
   // If the top match is effectively 'verbatim' but exceeds the calculated
   // verbatim relevance, and REQUESTED_URL |input_| has a |desired_tld|
   // (for example ".com" when the CTRL key is pressed for REQUESTED_URL input),
   // promote a URL_WHAT_YOU_TYPED match to the top. Otherwise, these matches can
   // stomp the HistoryURLProvider's similar transient URL_WHAT_YOU_TYPED match,
   // and CTRL+ENTER will invoke the search instead of the expected navigation.
@@ skipping 13 matching lines @@
 }
 
 bool SearchProvider::IsTopMatchScoreTooLow() const {
   return matches_.front().relevance < CalculateRelevanceForVerbatim();
 }
 
 bool SearchProvider::IsTopMatchHighRankSearchForURL() const {
   return input_.type() == AutocompleteInput::URL &&
          matches_.front().relevance > CalculateRelevanceForVerbatim() &&
          (matches_.front().type == AutocompleteMatch::SEARCH_SUGGEST ||
-          matches_.front().type == AutocompleteMatch::SEARCH_WHAT_YOU_TYPED);
+          matches_.front().type == AutocompleteMatch::SEARCH_WHAT_YOU_TYPED ||
+          matches_.front().type == AutocompleteMatch::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.  We attempt to
+  // CHECK this assumption in UpdateMatches().
   return matches_.front().type != AutocompleteMatch::SEARCH_WHAT_YOU_TYPED &&
          matches_.front().type != AutocompleteMatch::URL_WHAT_YOU_TYPED &&
+         matches_.front().type != AutocompleteMatch::SEARCH_OTHER_ENGINE &&
          matches_.front().inline_autocomplete_offset == string16::npos &&
          matches_.front().fill_into_edit != input_.text();
 }
 
 void SearchProvider::UpdateMatches() {
   ConvertResultsToAutocompleteMatches();
 
+#ifdef DEBUG

[msw, 2013/02/05 01:35:19]

Shoot, I thought you were going to put this into a unit test; it's probably
overkill here. But now that I think about it, you already test for the the
content of the keyword matches, so maybe adding a test like that isn't necessary
at all... sorry.

[Mark P, 2013/02/05 19:50:55]

Removed.

At least it's now in the code review history so if we want it  back we can
easily bring it back.

+  // Check that SEARCH_OTHER_ENGINE match is actually the verbatim search
+  // query on the keyword provider.
+  for (int i = 0; i < matches_.size(); ++i) {
+    const AutocompleteMatch& m = matches_[i];
+    if (m.type == AutocompleteMatch::SEARCH_OTHER_ENGINE) {
+      // Verify that input_.text() begins with the keyword (possibly
+      // with an ignorable prefix before it) and ends with the text
+      // displayed in this match and that the only text in between is
+      // entirely whitespace.
+      const URLPrefix* prefix =
+          URLPrefix::BestURLPrefix(input_.text(), "");
+      // There will always be a valid prefix; it may be empty.
+      DCHECK(prefix);
+      string16 input_after_prefix = input_.text().substr(prefix.length());
+      // case-insensitive for keyword name
+      DCHECK(base::StartsWith(input_after_prefix, m.keyword, false));
+      string16 input_after_keyword =
+          input_after_prefix.substr(m.keyword.length());
+      // case-sensitive match for remaining text
+      DCHECK(base::EndsWith(input_after_keyword, m.contents, true));
+      string16::size_t pos_of_remaining_text =
+          input_after_keyword.find(m.contents);
+      DCHECK_NE(pos_of_remaining_text, string16::npos);
+      DCHECK_GT(pos_of_remaining_text, 0u);
+      DCHECK(base::ContainsOnlyWhitespace(
+          input_after_keyword.substr(0, pos_of_remaining_text)));
+    }
+  }
+#endif
+
   // Check constraints that may be violated by suggested relevances.
   if (!matches_.empty() &&
       (has_suggested_relevance_ || verbatim_relevance_ >= 0)) {
     // These two blocks attempt to repair undesriable behavior by suggested
     // relevances with minimal impact, preserving other suggested relevances.
     if (IsTopMatchScoreTooLow()) {
       // Disregard the suggested verbatim relevance if the top score is below
       // the usual verbatim value. For example, a BarProvider may rely on
       // SearchProvider's verbatim or inlineable matches for input "foo" to
       // always outrank its own lowly-ranked non-inlineable "bar" match.
       verbatim_relevance_ = -1;
       ConvertResultsToAutocompleteMatches();
     }
     if (IsTopMatchHighRankSearchForURL()) {
       // 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_suggest_results_, true);
       ApplyCalculatedSuggestRelevance(&default_suggest_results_, false);
       verbatim_relevance_ = -1;
       ConvertResultsToAutocompleteMatches();
     }
     if (IsTopMatchNotInlinable()) {
-      // Disregard suggested relevances if the top match is not SWYT, inlinable,
-      // or URL_WHAT_YOU_TYPED (which may be top match regardless of inlining).
-      // For example, input "foo" should not invoke a search for "bar", which
-      // would happen if the "bar" search match outranked all other matches.
+      // Disregard suggested relevances if the top match is not a verbatim
+      // match, inlinable, or URL_WHAT_YOU_TYPED (which may be top match
+      // regardless of inlining).  For example, input "foo" should not
+      // invoke a search for "bar", which would happen if the "bar" search
+      // match outranked all other matches.
       ApplyCalculatedRelevance();
       ConvertResultsToAutocompleteMatches();
     }
     DCHECK(!IsTopMatchScoreTooLow());
     DCHECK(!IsTopMatchHighRankSearchForURL());
     DCHECK(!IsTopMatchNotInlinable());
   }
 
   UpdateStarredStateOfMatches();
   UpdateDone();
@@ skipping 164 matching lines @@
 
     case AutocompleteInput::URL:
       return 850;
 
     default:
       NOTREACHED();
       return 0;
   }
 }
 
+// static
+int SearchProvider::CalculateRelevanceForKeywordVerbatim(
+    AutocompleteInput::Type type,
+    bool prefer_keyword) {
+  // Perhaps this should be kept similar to
+  // KeywordProvider::CalculateRelevance().  That function calculates,
+  // among other things, the verbatim query score for search keywords
+  // but only extension-based ones.  It would be a bit odd if the score
+  // for a verbatim query for an extension keyword and for a
+  // non-extension keyword differed dramatically (though no immediate
+  // harm would come from it).
+  if (prefer_keyword)
+    return 1500;
+  return type == AutocompleteInput::QUERY ? 1450 : 1100;
+}
+
 int SearchProvider::CalculateRelevanceForHistory(
     const Time& time,
     bool is_keyword,
     bool prevent_inline_autocomplete) const {
   // The relevance of past searches falls off over time. There are two distinct
   // equations used. If the first equation is used (searches to the primary
   // provider that we want to inline autocomplete), the score starts at 1399 and
   // falls to 1300. If the second equation is used the relevance of a search 15
   // minutes ago is discounted 50 points, while the relevance of a search two
   // weeks ago is discounted 450 points.
@@ skipping 198 matching lines @@
 }
 
 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) &&
            (instant_finalized_ ||
             (!chrome::BrowserInstantController::IsInstantEnabled(profile_) &&
              !chrome::search::IsInstantExtendedAPIEnabled(profile_))));
 }