Allow the history URL provider to handle input of type QUERY. This helps in ...

chrome/browser/autocomplete/search_provider.cc

 // Copyright (c) 2009 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 "app/l10n_util.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
@@ skipping 503 matching lines @@
   done_ = !history_request_pending_ && !suggest_results_pending_;
 }
 
 void SearchProvider::AddNavigationResultsToMatches(
     const NavigationResults& navigation_results,
     bool is_keyword) {
   if (!navigation_results.empty()) {
     // TODO(kochi): http://b/1170574  We add only one results for navigational
     // suggestions. If we can get more useful information about the score,
     // consider adding more results.
-    matches_.push_back(
-        NavigationToMatch(navigation_results.front(),
-                          CalculateRelevanceForNavigation(0, is_keyword),
-                          is_keyword));
+    const size_t num_results = is_keyword ?
+        keyword_navigation_results_.size() : default_navigation_results_.size();
+    matches_.push_back(NavigationToMatch(navigation_results.front(),
+        CalculateRelevanceForNavigation(num_results, 0, is_keyword),
+        is_keyword));
   }
 }
 
 void SearchProvider::AddHistoryResultsToMap(const HistoryResults& results,
                                             bool is_keyword,
                                             int did_not_accept_suggestion,
                                             MatchMap* map) {
   for (HistoryResults::const_iterator i(results.begin()); i != results.end();
        ++i) {
     AddMatchToMap(i->term, CalculateRelevanceForHistory(i->time, is_keyword),
                   AutocompleteMatch::SEARCH_HISTORY, did_not_accept_suggestion,
                   is_keyword, map);
   }
 }
 
 void SearchProvider::AddSuggestResultsToMap(
     const SuggestResults& suggest_results,
     bool is_keyword,
     int did_not_accept_suggestion,
     MatchMap* map) {
   for (size_t i = 0; i < suggest_results.size(); ++i) {
     AddMatchToMap(suggest_results[i],
-                  CalculateRelevanceForSuggestion(suggest_results, i,
+                  CalculateRelevanceForSuggestion(suggest_results.size(), i,
                                                   is_keyword),
                   AutocompleteMatch::SEARCH_SUGGEST,
                   static_cast<int>(i), is_keyword, map);
   }
 }
 
 int SearchProvider::CalculateRelevanceForWhatYouTyped() const {
+  if (providers_.valid_keyword_provider())
+    return 250;
+
   switch (input_.type()) {
     case AutocompleteInput::UNKNOWN:
-      return providers_.valid_keyword_provider() ? 250 : 1300;
+    case AutocompleteInput::QUERY:
+    case AutocompleteInput::FORCED_QUERY:
+      return 1300;
 
     case AutocompleteInput::REQUESTED_URL:
-      return providers_.valid_keyword_provider() ? 250 : 1200;
+      return 1150;
 
     case AutocompleteInput::URL:
-      return providers_.valid_keyword_provider() ? 250 : 850;
-
-    case AutocompleteInput::QUERY:
-      return providers_.valid_keyword_provider() ? 250 : 1300;
-
-    case AutocompleteInput::FORCED_QUERY:
-      return providers_.valid_keyword_provider() ? 250 : 1500;
+      return 850;
 
     default:
       NOTREACHED();
       return 0;
   }
 }
 
 int SearchProvider::CalculateRelevanceForHistory(const Time& time,
                                                  bool is_keyword) const {
   // The relevance of past searches falls off over time.  This curve is chosen
   // so that the relevance of a search 15 minutes ago is discounted about 50
   // points, while the relevance of a search two weeks ago is discounted about
   // 450 points.
   const double elapsed_time = std::max((Time::Now() - time).InSecondsF(), 0.);
   const int score_discount = static_cast<int>(6.5 * pow(elapsed_time, 0.3));
 
   // Don't let scores go below 0.  Negative relevance scores are meaningful in
   // a different way.
   int base_score;
-  bool is_primary = providers_.is_primary_provider(is_keyword);
-  switch (input_.type()) {
-    case AutocompleteInput::UNKNOWN:
-    case AutocompleteInput::REQUESTED_URL:
-      base_score = is_primary ? 1050 : 200;
-      break;
-
-    case AutocompleteInput::URL:
-      base_score = is_primary ? 750 : 200;
-      break;
-
-    case AutocompleteInput::QUERY:
-    case AutocompleteInput::FORCED_QUERY:
-      base_score = is_primary ? 1250 : 200;
-      break;
-
-    default:
-      NOTREACHED();
-      base_score = 0;
-      break;
-  }
+  if (!providers_.is_primary_provider(is_keyword))
+    base_score = 200;
+  else
+    base_score = (input_.type() == AutocompleteInput::URL) ? 750 : 1050;
   return std::max(0, base_score - score_discount);
 }
 
-int SearchProvider::CalculateRelevanceForSuggestion(
-    const SuggestResults& suggest_results,
-    size_t suggestion_number,
-    bool is_keyword) const {
-  DCHECK(suggestion_number < suggest_results.size());
-  bool is_primary = providers_.is_primary_provider(is_keyword);
-  const int suggestion_value =
-      static_cast<int>(suggest_results.size() - 1 - suggestion_number);
-  switch (input_.type()) {
-    case AutocompleteInput::UNKNOWN:
-    case AutocompleteInput::REQUESTED_URL:
-      return suggestion_value + (is_primary ? 600 : 100);
-
-    case AutocompleteInput::URL:
-      return suggestion_value + (is_primary ? 300 : 100);
-
-    case AutocompleteInput::QUERY:
-    case AutocompleteInput::FORCED_QUERY:
-      return suggestion_value + (is_primary ? 800 : 100);
-
-    default:
-      NOTREACHED();
-      return 0;
-  }
+int SearchProvider::CalculateRelevanceForSuggestion(size_t num_results,
+                                                    size_t result_number,
+                                                    bool is_keyword) const {
+  DCHECK(result_number < num_results);
+  int base_score;
+  if (!providers_.is_primary_provider(is_keyword))
+    base_score = 100;
+  else
+    base_score = (input_.type() == AutocompleteInput::URL) ? 300 : 600;
+  return base_score +
+      static_cast<int>(num_results - 1 - result_number);
 }
 
-int SearchProvider::CalculateRelevanceForNavigation(
-    size_t suggestion_number,
-    bool is_keyword) const {
-  DCHECK(
-      (is_keyword && suggestion_number < keyword_navigation_results_.size()) ||
-      (!is_keyword && suggestion_number < default_navigation_results_.size()));
+int SearchProvider::CalculateRelevanceForNavigation(size_t num_results,
+                                                    size_t result_number,
+                                                    bool is_keyword) const {
+  DCHECK(result_number < num_results);
   // TODO(kochi): http://b/784900  Use relevance score from the NavSuggest
   // server if possible.
-  bool is_primary = providers_.is_primary_provider(is_keyword);
-  switch (input_.type()) {
-    case AutocompleteInput::QUERY:
-    case AutocompleteInput::FORCED_QUERY:
-      return static_cast<int>(suggestion_number) + (is_primary ? 1000 : 150);
-
-    default:
-      return static_cast<int>(suggestion_number) + (is_primary ? 800 : 150);
-  }
+  return (providers_.is_primary_provider(is_keyword) ? 800 : 150) +
+      static_cast<int>(num_results - 1 - result_number);
 }
 
 void SearchProvider::AddMatchToMap(const std::wstring& query_string,
                                    int relevance,
                                    AutocompleteMatch::Type type,
                                    int accepted_suggestion,
                                    bool is_keyword,
                                    MatchMap* map) {
   const std::wstring& input_text =
       is_keyword ? keyword_input_text_ : input_.text();
@@ skipping 122 matching lines @@
   // 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(L"?");
   match.fill_into_edit.append(match.contents);
   // TODO(pkasting): http://b/1112879 These should perhaps be
   // inline-autocompletable?
 
   return match;
 }