Omnibox: Demote Bookmarklets without Title Matches

chrome/browser/autocomplete/bookmark_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/bookmark_provider.h"
 
 #include <algorithm>
 #include <functional>
 #include <vector>
 
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.h"
 #include "chrome/browser/autocomplete/history_provider.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "components/bookmarks/browser/bookmark_match.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/metrics/proto/omnibox_input_type.pb.h"
 #include "components/omnibox/autocomplete_result.h"
 #include "components/omnibox/url_prefix.h"
 #include "net/base/net_util.h"
+#include "url/url_constants.h"
 
 using bookmarks::BookmarkMatch;
 
 typedef std::vector<BookmarkMatch> BookmarkMatches;
 
 namespace {
 
 // Removes leading spaces from |title| before displaying, otherwise it looks
 // funny.  In the process, corrects |title_match_positions| so the correct
 // characters are highlighted.
@@ skipping 219 matching lines @@
   // matches, keeping only the longest.  Together these mean that each
   // character is included in at most one match.)  If there are matches in the
   // URL, the sum can be greater.
   //
   // This sum is then normalized by the length of the bookmark title + 10
   // and capped at 1.0.  The +10 is to expand the scoring range so fewer
   // bookmarks will hit the 1.0 cap and hence lose all ability to distinguish
   // between these high-quality bookmarks.
   //
   // The normalized value is multiplied against the scoring range available,
-  // which is 299.  The 299 is calculated by subtracting the minimum possible
-  // score, 900, from the maximum possible score, 1199.  This product, ranging
-  // from 0 to 299, is added to the minimum possible score, 900, giving the
-  // preliminary score.
+  // which is the difference between the minimum possible score and the maximum
+  // possible score.  This product is added to the minimum possible score to
+  // give the preliminary score.
   //
   // If the preliminary score is less than the maximum possible score, 1199,
   // it can be boosted up to that maximum possible score if the URL referenced
   // by the bookmark is also referenced by any of the user's other bookmarks.
   // A count of how many times the bookmark's URL is referenced is determined
   // and, for each additional reference beyond the one for the bookmark being
   // scored up to a maximum of three, the score is boosted by a fixed amount
   // given by |kURLCountBoost|, below.
   //
 
   // Pretend empty titles are identical to the URL.
   if (title.empty())
     title = base::ASCIIToUTF16(url.spec());
   ScoringFunctor title_position_functor =
       for_each(bookmark_match.title_match_positions.begin(),
                bookmark_match.title_match_positions.end(),
                ScoringFunctor(title.size()));
   ScoringFunctor url_position_functor =
       for_each(bookmark_match.url_match_positions.begin(),
                bookmark_match.url_match_positions.end(),
                ScoringFunctor(bookmark_match.node->url().spec().length()));
-  const double summed_factors = title_position_functor.ScoringFactor() +
+  const double title_match_strength = title_position_functor.ScoringFactor();
+  const double summed_factors = title_match_strength +
       url_position_functor.ScoringFactor();
   const double normalized_sum =
       std::min(summed_factors / (title.size() + 10), 1.0);
-  const int kBaseBookmarkScore = 900;
-  const int kMaxBookmarkScore = 1199;
+  // Bookmarks with javascript scheme ("bookmarklets") that do not have title
+  // matches get a lower base and lower maximum score because returning them
+  // for matches in their (often very long) URL looks stupid and is often not
+  // intended by the user.
+  const bool bookmarklet_without_title_match =
+      url.SchemeIs(url::kJavaScriptScheme) && (title_match_strength == 0.0);
+  const int kBaseBookmarkScore = bookmarklet_without_title_match ? 400 : 900;
+  const int kMaxBookmarkScore = bookmarklet_without_title_match ? 799 : 1199;
   const double kBookmarkScoreRange =
       static_cast<double>(kMaxBookmarkScore - kBaseBookmarkScore);
   match.relevance = static_cast<int>(normalized_sum * kBookmarkScoreRange) +
       kBaseBookmarkScore;
   // Don't waste any time searching for additional referenced URLs if we
   // already have a perfect title match.
   if (match.relevance >= kMaxBookmarkScore)
     return match;
   // Boost the score if the bookmark's URL is referenced by other bookmarks.
   const int kURLCountBoost[4] = { 0, 75, 125, 150 };
@@ skipping 25 matching lines @@
        i != positions.end();
        ++i) {
     AutocompleteMatch::ACMatchClassifications new_class;
     AutocompleteMatch::ClassifyLocationInString(i->first, i->second - i->first,
         text_length, url_style, &new_class);
     classifications = AutocompleteMatch::MergeClassifications(
         classifications, new_class);
   }
   return classifications;
 }