Omnibox: Make Keyword Provide More Generous with Matching

components/omnibox/browser/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 "components/omnibox/browser/search_provider.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/base64.h"
@@ skipping 119 matching lines @@
   // |template_url_service| can be null in tests.
   if (template_url_service)
     template_url_service->AddObserver(this);
 }
 
 // static
 std::string SearchProvider::GetSuggestMetadata(const AutocompleteMatch& match) {
   return match.GetAdditionalInfo(kSuggestMetadataKey);
 }
 
+void SearchProvider::RegisterDisplayedAnswers(
+    const AutocompleteResult& result) {
+  if (result.empty())
+    return;
+
+  // The answer must be in the first or second slot to be considered. It should
+  // only be in the second slot if AutocompleteController ranked a local search
+  // history or a verbatim item higher than the answer.
+  AutocompleteResult::const_iterator match = result.begin();
+  if (match->answer_contents.empty() && result.size() > 1)
+    ++match;
+  if (match->answer_contents.empty() || match->answer_type.empty() ||
+      match->fill_into_edit.empty())
+    return;
+
+  // Valid answer encountered, cache it for further queries.
+  answers_cache_.UpdateRecentAnswers(match->fill_into_edit, match->answer_type);
+}
+
+// static
+int SearchProvider::CalculateRelevanceForKeywordVerbatim(
+    metrics::OmniboxInputType::Type type,
+    bool allow_exact_keyword_match,
+    bool prefer_keyword) {
+  // This function is responsible for scoring verbatim query matches
+  // for non-extension substituting keywords.
+  // KeywordProvider::CalculateRelevance() scores all other types of
+  // keyword verbatim matches.
+  if (allow_exact_keyword_match && prefer_keyword)
+    return 1500;
+  return (allow_exact_keyword_match &&
+          (type == metrics::OmniboxInputType::QUERY)) ?
+      1450 : 1100;
+}
+
 void SearchProvider::ResetSession() {
   set_field_trial_triggered_in_session(false);
 }
 
-void SearchProvider::OnTemplateURLServiceChanged() {
-  // Only update matches at this time if we haven't already claimed we're done
-  // processing the query.
-  if (done_)
-    return;
-
-  // Check that the engines we're using weren't renamed or deleted.  (In short,
-  // require that an engine still exists with the keywords in use.)  For each
-  // deleted engine, cancel the in-flight request if any, drop its suggestions,
-  // and, in the case when the default provider was affected, point the cached
-  // default provider keyword name at the new name for the default provider.
-
-  // Get...ProviderURL() looks up the provider using the cached keyword name
-  // stored in |providers_|.
-  const TemplateURL* template_url = providers_.GetDefaultProviderURL();
-  if (!template_url) {
-    CancelFetcher(&default_fetcher_);
-    default_results_.Clear();
-    providers_.set(client()
-                       ->GetTemplateURLService()
-                       ->GetDefaultSearchProvider()
-                       ->keyword(),
-                   providers_.keyword_provider());
-  }
-  template_url = providers_.GetKeywordProviderURL();
-  if (!providers_.keyword_provider().empty() && !template_url) {
-    CancelFetcher(&keyword_fetcher_);
-    keyword_results_.Clear();
-    providers_.set(providers_.default_provider(), base::string16());
-  }
-  // It's possible the template URL changed without changing associated keyword.
-  // Hence, it's always necessary to update matches to use the new template
-  // URL.  (One could cache the template URL and only call UpdateMatches() and
-  // OnProviderUpdate() if a keyword was deleted/renamed or the template URL
-  // was changed.  That would save extra calls to these functions.  However,
-  // this is uncommon and not likely to be worth the extra work.)
-  UpdateMatches();
-  listener_->OnProviderUpdate(true);  // always pretend something changed
-}
-
 SearchProvider::~SearchProvider() {
   TemplateURLService* template_url_service = client()->GetTemplateURLService();
   if (template_url_service)
     template_url_service->RemoveObserver(this);
 }
 
 // static
-int SearchProvider::CalculateRelevanceForKeywordVerbatim(
-    metrics::OmniboxInputType::Type type,
-    bool prefer_keyword) {
-  // This function is responsible for scoring verbatim query matches
-  // for non-extension keywords.  KeywordProvider::CalculateRelevance()
-  // scores verbatim query matches for extension keywords, as well as
-  // for keyword matches (i.e., suggestions of a keyword itself, not a
-  // suggestion of a query on a keyword search engine).  These two
-  // functions are currently in sync, but there's no reason we
-  // couldn't decide in the future to score verbatim matches
-  // differently for extension and non-extension keywords.  If you
-  // make such a change, however, you should update this comment to
-  // describe it, so it's clear why the functions diverge.
-  if (prefer_keyword)
-    return 1500;
-  return (type == metrics::OmniboxInputType::QUERY) ? 1450 : 1100;
-}
-
-// static
 void SearchProvider::UpdateOldResults(
     bool minimal_changes,
     SearchSuggestionParser::Results* results) {
   // When called without |minimal_changes|, it likely means the user has
   // pressed a key.  Revise the cached results appropriately.
   if (!minimal_changes) {
     for (SearchSuggestionParser::SuggestResults::iterator sug_it =
              results->suggest_results.begin();
          sug_it != results->suggest_results.end(); ) {
       if (sug_it->type() == AutocompleteMatchType::CALCULATOR) {
@@ skipping 141 matching lines @@
 void SearchProvider::RecordDeletionResult(bool success) {
   if (success) {
     base::RecordAction(
         base::UserMetricsAction("Omnibox.ServerSuggestDelete.Success"));
   } else {
     base::RecordAction(
         base::UserMetricsAction("Omnibox.ServerSuggestDelete.Failure"));
   }
 }
 
+void SearchProvider::OnTemplateURLServiceChanged() {
+  // Only update matches at this time if we haven't already claimed we're done
+  // processing the query.
+  if (done_)
+    return;
+
+  // Check that the engines we're using weren't renamed or deleted.  (In short,
+  // require that an engine still exists with the keywords in use.)  For each
+  // deleted engine, cancel the in-flight request if any, drop its suggestions,
+  // and, in the case when the default provider was affected, point the cached
+  // default provider keyword name at the new name for the default provider.
+
+  // Get...ProviderURL() looks up the provider using the cached keyword name
+  // stored in |providers_|.
+  const TemplateURL* template_url = providers_.GetDefaultProviderURL();
+  if (!template_url) {
+    CancelFetcher(&default_fetcher_);
+    default_results_.Clear();
+    providers_.set(client()
+                       ->GetTemplateURLService()
+                       ->GetDefaultSearchProvider()
+                       ->keyword(),
+                   providers_.keyword_provider());
+  }
+  template_url = providers_.GetKeywordProviderURL();
+  if (!providers_.keyword_provider().empty() && !template_url) {
+    CancelFetcher(&keyword_fetcher_);
+    keyword_results_.Clear();
+    providers_.set(providers_.default_provider(), base::string16());
+  }
+  // It's possible the template URL changed without changing associated keyword.
+  // Hence, it's always necessary to update matches to use the new template
+  // URL.  (One could cache the template URL and only call UpdateMatches() and
+  // OnProviderUpdate() if a keyword was deleted/renamed or the template URL
+  // was changed.  That would save extra calls to these functions.  However,
+  // this is uncommon and not likely to be worth the extra work.)
+  UpdateMatches();
+  listener_->OnProviderUpdate(true);  // always pretend something changed
+}
+
 void SearchProvider::OnURLFetchComplete(const net::URLFetcher* source) {
   DCHECK(!done_);
   const bool is_keyword = source == keyword_fetcher_.get();
 
   // Ensure the request succeeded and that the provider used is still available.
   // A verbatim match cannot be generated without this provider, causing errors.
   const bool request_succeeded =
       source->GetStatus().is_success() && (source->GetResponseCode() == 200) &&
       GetTemplateURL(is_keyword);
 
@@ skipping 936 matching lines @@
       (keyword_results_.verbatim_relevance >= 0) &&
       !input_.prevent_inline_autocomplete() &&
       ((keyword_results_.verbatim_relevance > 0) ||
        !keyword_results_.suggest_results.empty() ||
        !keyword_results_.navigation_results.empty());
   if (relevance_from_server)
     *relevance_from_server = use_server_relevance;
   return use_server_relevance ?
       keyword_results_.verbatim_relevance :
       CalculateRelevanceForKeywordVerbatim(keyword_input_.type(),
+                                           true,
                                            keyword_input_.prefer_keyword());
 }
 
 int SearchProvider::CalculateRelevanceForHistory(
     const base::Time& time,
     bool is_keyword,
     bool use_aggressive_method,
     bool prevent_search_history_inlining) 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
@@ skipping 128 matching lines @@
     std::replace(current_token_.begin(), current_token_.end(), '+', '-');
     std::replace(current_token_.begin(), current_token_.end(), '/', '_');
   }
 
   // Extend expiration time another 60 seconds.
   token_expiration_time_ = current_time + base::TimeDelta::FromSeconds(60);
 
   return current_token_;
 }
 
-void SearchProvider::RegisterDisplayedAnswers(
-    const AutocompleteResult& result) {
-  if (result.empty())
-    return;
-
-  // The answer must be in the first or second slot to be considered. It should
-  // only be in the second slot if AutocompleteController ranked a local search
-  // history or a verbatim item higher than the answer.
-  AutocompleteResult::const_iterator match = result.begin();
-  if (match->answer_contents.empty() && result.size() > 1)
-    ++match;
-  if (match->answer_contents.empty() || match->answer_type.empty() ||
-      match->fill_into_edit.empty())
-    return;
-
-  // Valid answer encountered, cache it for further queries.
-  answers_cache_.UpdateRecentAnswers(match->fill_into_edit, match->answer_type);
-}
-
 AnswersQueryData SearchProvider::FindAnswersPrefetchData() {
   // Retrieve the top entry from scored history results.
   MatchMap map;
   AddTransformedHistoryResultsToMap(transformed_keyword_history_results_,
                                     TemplateURLRef::NO_SUGGESTIONS_AVAILABLE,
                                     &map);
   AddTransformedHistoryResultsToMap(transformed_default_history_results_,
                                     TemplateURLRef::NO_SUGGESTIONS_AVAILABLE,
                                     &map);
 
   ACMatches matches;
   for (MatchMap::const_iterator i(map.begin()); i != map.end(); ++i)
     matches.push_back(i->second);
   std::sort(matches.begin(), matches.end(), &AutocompleteMatch::MoreRelevant);
 
   // If there is a top scoring entry, find the corresponding answer.
   if (!matches.empty())
     return answers_cache_.GetTopAnswerEntry(matches[0].contents);
 
   return AnswersQueryData();
 }