Omnibox: Bug Fixes for Shortcuts Inlining

chrome/browser/autocomplete/shortcuts_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/shortcuts_provider.h"
 
 #include <algorithm>
 #include <cmath>
 #include <map>
 #include <vector>
 
 #include "base/i18n/break_iterator.h"
 #include "base/i18n/case_conversion.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/autocomplete/autocomplete_input.h"
 #include "chrome/browser/autocomplete/autocomplete_provider_listener.h"
 #include "chrome/browser/autocomplete/autocomplete_result.h"
+#include "chrome/browser/autocomplete/history_provider.h"
 #include "chrome/browser/autocomplete/url_prefix.h"
 #include "chrome/browser/history/history_notifications.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/history/shortcuts_backend_factory.h"
 #include "chrome/browser/omnibox/omnibox_field_trial.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/common/net/url_fixer_upper.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "url/url_parse.h"
 
 namespace {
 
 class DestinationURLEqualsURL {
  public:
   explicit DestinationURLEqualsURL(const GURL& url) : url_(url) {}
   bool operator()(const AutocompleteMatch& match) const {
     return match.destination_url == url_;
   }
  private:
   const GURL url_;
 };
 
+// Like URLPrefix::BestURLPrefix() except also handles the prefix of
+// "www.".  This is needed because sometimes the string we're matching
+// against here (which comes from |fill_into_edit|) can start with
+// "www." without having a protocol at the beginning.  Because "www."
+// is not on the default prefix list, we test for it explicitly here
+// and use that match if the default list didn't have a match or the
+// default list's match was shorter than it could've been.
+const URLPrefix* BestURLPrefixWithWWWCase(
+    const base::string16& text,
+    const base::string16& prefix_suffix) {
+  const URLPrefix* best_prefix = URLPrefix::BestURLPrefix(text, prefix_suffix);
+  URLPrefix www_prefix(ASCIIToUTF16("www."), 1);
+  if ((best_prefix == NULL) ||
+      (best_prefix->num_components < www_prefix.num_components)) {
+    if (URLPrefix::PrefixMatch(www_prefix, text, prefix_suffix))
+      best_prefix = &www_prefix;
+  }
+  return best_prefix;
+}
+
 }  // namespace
 
 ShortcutsProvider::ShortcutsProvider(AutocompleteProviderListener* listener,
                                      Profile* profile)
     : AutocompleteProvider(listener, profile,
           AutocompleteProvider::TYPE_SHORTCUTS),
       languages_(profile_->GetPrefs()->GetString(prefs::kAcceptLanguages)),
       initialized_(false) {
   scoped_refptr<history::ShortcutsBackend> backend =
       ShortcutsBackendFactory::GetForProfile(profile_);
@@ skipping 70 matching lines @@
 void ShortcutsProvider::GetMatches(const AutocompleteInput& input) {
   scoped_refptr<history::ShortcutsBackend> backend =
       ShortcutsBackendFactory::GetForProfileIfExists(profile_);
   if (!backend.get())
     return;
   // Get the URLs from the shortcuts database with keys that partially or
   // completely match the search term.
   base::string16 term_string(base::i18n::ToLower(input.text()));
   DCHECK(!term_string.empty());
 
+  base::string16 fixed_up_term_string(term_string);
+  AutocompleteInput fixed_up_input(input);
+  if (HistoryProvider::FixupUserInput(&fixed_up_input))
+    fixed_up_term_string = fixed_up_input.text();
+
   int max_relevance;
   if (!OmniboxFieldTrial::ShortcutsScoringMaxRelevance(
       input.current_page_classification(), &max_relevance))
     max_relevance = AutocompleteResult::kLowestDefaultScore - 1;
 
   for (history::ShortcutsBackend::ShortcutMap::const_iterator it =
            FindFirstMatch(term_string, backend.get());
        it != backend->shortcuts_map().end() &&
            StartsWith(it->first, term_string, true); ++it) {
     // Don't return shortcuts with zero relevance.
     int relevance = CalculateScore(term_string, it->second, max_relevance);
     if (relevance) {
       matches_.push_back(ShortcutToACMatch(
-          it->second, relevance, term_string,
+          it->second, relevance, term_string, fixed_up_term_string,
           input.prevent_inline_autocomplete()));
     }
   }
   std::partial_sort(matches_.begin(),
       matches_.begin() +
           std::min(AutocompleteProvider::kMaxMatches, matches_.size()),
       matches_.end(), &AutocompleteMatch::MoreRelevant);
   if (matches_.size() > AutocompleteProvider::kMaxMatches) {
     matches_.erase(matches_.begin() + AutocompleteProvider::kMaxMatches,
                    matches_.end());
@@ skipping 15 matching lines @@
     it->relevance = max_relevance;
     if (max_relevance > 1)
       --max_relevance;
   }
 }
 
 AutocompleteMatch ShortcutsProvider::ShortcutToACMatch(
     const history::ShortcutsBackend::Shortcut& shortcut,
     int relevance,
     const base::string16& term_string,
-    bool prevent_inline_autocomplete) {
+    const base::string16& fixed_up_term_string,
+    const bool prevent_inline_autocomplete) {
   DCHECK(!term_string.empty());
   AutocompleteMatch match(shortcut.match_core.ToMatch());
   match.provider = this;
   match.relevance = relevance;
   match.deletable = true;
   DCHECK(match.destination_url.is_valid());
   match.RecordAdditionalInfo("number of hits", shortcut.number_of_hits);
   match.RecordAdditionalInfo("last access time", shortcut.last_access_time);
   match.RecordAdditionalInfo("original input text", UTF16ToUTF8(shortcut.text));
 
   // Set |inline_autocompletion| and |allowed_to_be_default_match| if possible.
   // If the match is a search query this is easy: simply check whether the
   // user text is a prefix of the query.  If the match is a navigation, we
   // assume the fill_into_edit looks something like a URL, so we use
   // BestURLPrefix() to try and strip off any prefixes that the user might
   // not think would change the meaning, but would otherwise prevent inline
   // autocompletion.  This allows, for example, the input of "foo.c" to
   // autocomplete to "foo.com" for a fill_into_edit of "http://foo.com".
   if (AutocompleteMatch::IsSearchType(match.type)) {
     if (StartsWith(match.fill_into_edit, term_string, false)) {
       match.inline_autocompletion =
           match.fill_into_edit.substr(term_string.length());
       match.allowed_to_be_default_match =
           !prevent_inline_autocomplete || match.inline_autocompletion.empty();
     }
   } else {
     const URLPrefix* best_prefix =
-        URLPrefix::BestURLPrefix(match.fill_into_edit, term_string);
-    URLPrefix www_prefix(ASCIIToUTF16("www."), 1);
-    if ((best_prefix == NULL) ||
-        (best_prefix->num_components < www_prefix.num_components)) {
-      // Sometimes |fill_into_edit| can start with "www." without having a
-      // protocol at the beginning.  Because "www." is not on the default
-      // prefix list, we test for it explicitly here and use that match if
-      // the default list didn't have a match or the default list's match
-      // was shorter than it could've been.
-      if (URLPrefix::PrefixMatch(www_prefix, match.fill_into_edit, term_string))
-        best_prefix = &www_prefix;
+        BestURLPrefixWithWWWCase(match.fill_into_edit, term_string);
+    const base::string16* matching_string = &term_string;
+    // If we failed to find a best_prefix initially, try again using a
+    // fixed-up version of the user input.  This is especially useful
+    // to get about: URLs to inline against chrome:// shortcuts.
+    // (about: URLs are fixed up to the chrome:// scheme.)
+    if ((best_prefix == NULL) && !fixed_up_term_string.empty() &&
+        (fixed_up_term_string != term_string)) {
+        best_prefix = BestURLPrefixWithWWWCase(
+            match.fill_into_edit, fixed_up_term_string);
+        matching_string = &fixed_up_term_string;
     }
     if (best_prefix != NULL) {
       match.inline_autocompletion = match.fill_into_edit.substr(
-          best_prefix->prefix.length() + term_string.length());
+          best_prefix->prefix.length() + matching_string->length());
       match.allowed_to_be_default_match =
           !prevent_inline_autocomplete || match.inline_autocompletion.empty();
     }
   }
 
   // Try to mark pieces of the contents and description as matches if they
   // appear in |term_string|.
   WordMap terms_map(CreateWordMapForString(term_string));
   if (!terms_map.empty()) {
     match.contents_class = ClassifyAllMatchesInString(term_string, terms_map,
@@ skipping 153 matching lines @@
   // (1.0 / each 5 additional hits), up to a maximum of 5x as long.
   const double kMaxDecaySpeedDivisor = 5.0;
   const double kNumUsesPerDecaySpeedDivisorIncrement = 5.0;
   double decay_divisor = std::min(kMaxDecaySpeedDivisor,
       (shortcut.number_of_hits + kNumUsesPerDecaySpeedDivisorIncrement - 1) /
       kNumUsesPerDecaySpeedDivisorIncrement);
 
   return static_cast<int>((base_score / exp(decay_exponent / decay_divisor)) +
       0.5);
 }