Make Omnibox HistoryURL Provider always aggressive.

chrome/browser/autocomplete/history_url_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/history_url_provider.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
-#include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
-#include "chrome/browser/autocomplete/autocomplete_field_trial.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/history/history_backend.h"
 #include "chrome/browser/history/history_database.h"
 #include "chrome/browser/history/history_types.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
@@ skipping 281 matching lines @@
       dont_suggest_exact_input(false) {
 }
 
 HistoryURLProviderParams::~HistoryURLProviderParams() {
 }
 
 HistoryURLProvider::HistoryURLProvider(ACProviderListener* listener,
                                        Profile* profile)
     : HistoryProvider(listener, profile, "HistoryURL"),
       prefixes_(GetPrefixes()),
-      params_(NULL),
-      enable_aggressive_scoring_(false) {
-  enum AggressivenessOption {
-    AGGRESSIVENESS_DISABLED = 0,
-    AGGRESSIVENESS_ENABLED = 1,
-    AGGRESSIVENESS_AUTO_BUT_NOT_IN_FIELD_TRIAL = 2,
-    AGGRESSIVENESS_FIELD_TRIAL_DEFAULT_GROUP = 3,
-    AGGRESSIVENESS_FIELD_TRIAL_EXPERIMENT_GROUP = 4,
-    NUM_OPTIONS = 5
-  };
-  // should always be overwritten
-  AggressivenessOption aggressiveness_option = NUM_OPTIONS;
-
-  const std::string switch_value = CommandLine::ForCurrentProcess()->
-      GetSwitchValueASCII(switches::kOmniboxAggressiveHistoryURL);
-  if (switch_value == switches::kOmniboxAggressiveHistoryURLEnabled) {
-    aggressiveness_option = AGGRESSIVENESS_ENABLED;
-    enable_aggressive_scoring_ = true;
-  } else if (switch_value == switches::kOmniboxAggressiveHistoryURLDisabled) {
-    aggressiveness_option = AGGRESSIVENESS_DISABLED;
-    enable_aggressive_scoring_ = false;
-  } else {
-    // Either: switch_value == switches::kOmniboxAggressiveHistoryURLAuto
-    // or someone passed an invalid command line flag.  We'll default
-    // the latter case to automatic but report an error.
-    if (!switch_value.empty() &&
-        (switch_value != switches::kOmniboxAggressiveHistoryURLAuto)) {
-      LOG(ERROR) << "Invalid --omnibox-aggressive-with-history-url option "
-                 << "received on command line: " << switch_value;
-      LOG(ERROR) << "Making automatic.";
-    }
-    // Automatic means eligible for the field trial.
-    // For the field trial stuff to work correctly, we must be running
-    // on the same thread as the thread that created the field trial,
-    // which happens via a call to AutocompleteFieldTrial::Active in
-    // chrome_browser_main.cc on the main thread.  Let's check this to
-    // be sure.  We check "if we've heard of the UI thread then we'd better
-    // be on it."  The first part is necessary so unit tests pass.  (Many
-    // unit tests don't set up the threading naming system; hence
-    // CurrentlyOn(UI thread) will fail.)
-    DCHECK(!content::BrowserThread::IsWellKnownThread(
-               content::BrowserThread::UI) ||
-           content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-    if (AutocompleteFieldTrial::InAggressiveHUPFieldTrial()) {
-      if (AutocompleteFieldTrial::InAggressiveHUPFieldTrialExperimentGroup()) {
-        enable_aggressive_scoring_ = true;
-        aggressiveness_option = AGGRESSIVENESS_FIELD_TRIAL_EXPERIMENT_GROUP;
-      } else {
-        enable_aggressive_scoring_ = false;
-        aggressiveness_option = AGGRESSIVENESS_FIELD_TRIAL_DEFAULT_GROUP;
-      }
-    } else {
-      enable_aggressive_scoring_ = false;
-      aggressiveness_option = AGGRESSIVENESS_AUTO_BUT_NOT_IN_FIELD_TRIAL;
-    }
-  }
-
-  // Add a beacon to the logs that'll allow us to identify later what
-  // aggressiveness state a user is in.  Do this by incrementing a
-  // bucket in a histogram, where the bucket represents the user's
-  // aggressiveness state.
-  UMA_HISTOGRAM_ENUMERATION(
-      "Omnibox.AggressiveHistoryURLProviderFieldTrialBeacon",
-      aggressiveness_option, NUM_OPTIONS);
+      params_(NULL) {
 }
 
 void HistoryURLProvider::Start(const AutocompleteInput& input,
                                bool minimal_changes) {
   // NOTE: We could try hard to do less work in the |minimal_changes| case
   // here; some clever caching would let us reuse the raw matches from the
   // history DB without re-querying.  However, we'd still have to go back to
   // the history thread to mark these up properly, and if pass 2 is currently
   // running, we'd need to wait for it to return to the main thread before
   // doing this (we can't just write new data for it to read due to thread
@@ skipping 133 matching lines @@
   // kMaxMatches results plus the What You Typed result, if it was added to
   // |history_matches| above.
   CullRedirects(backend, &history_matches, kMaxMatches + exact_suggestion);
 
   // Convert the history matches to autocomplete matches.
   for (size_t i = first_match; i < history_matches.size(); ++i) {
     const history::HistoryMatch& match = history_matches[i];
     DCHECK(!have_what_you_typed_match ||
            (match.url_info.url() !=
             GURL(params->matches.front().destination_url)));
-    // With aggressive scoring, we assume that the results are all of similar
-    // quality, so we give them consecutively decreasing scores.
-    relevance = (enable_aggressive_scoring_ && (relevance > 0)) ?
-       (relevance - 1) :
+    // If we've assigned a score already, all later matches score one
+    // less than the previous match.
+    relevance = (relevance > 0) ? (relevance - 1) :
        CalculateRelevance(NORMAL, history_matches.size() - 1 - i);
     AutocompleteMatch ac_match = HistoryMatchToACMatch(params, match,
         NORMAL, relevance);
     params->matches.push_back(ac_match);
   }
 }
 
 // Called on the main thread when the query is complete.
 void HistoryURLProvider::QueryComplete(
     HistoryURLProviderParams* params_gets_deleted) {
@@ skipping 42 matching lines @@
   prefixes.push_back(history::Prefix(ASCIIToUTF16("https://"), 1));
   prefixes.push_back(history::Prefix(ASCIIToUTF16("http://"), 1));
   prefixes.push_back(history::Prefix(ASCIIToUTF16("ftp://"), 1));
   // Empty string catches within-scheme matches as well.
   prefixes.push_back(history::Prefix(string16(), 0));
   return prefixes;
 }
 
 int HistoryURLProvider::CalculateRelevance(MatchType match_type,
                                            size_t match_number) const {
-  int shift = enable_aggressive_scoring_ ? kMaxMatches : 0;
-
   switch (match_type) {
     case INLINE_AUTOCOMPLETE:
-      return 1410 + shift;
+      return 1410 + kMaxMatches;
 
     case UNVISITED_INTRANET:
-      return 1400 + shift;
+      return 1400 + kMaxMatches;
 
     case WHAT_YOU_TYPED:
-      return 1200 + shift;
+      return 1200 + kMaxMatches;
 
     default:  // NORMAL
       return 900 + static_cast<int>(match_number);
   }
 }
 
 void HistoryURLProvider::RunAutocompletePasses(
     const AutocompleteInput& input,
     bool fixup_input_and_run_pass_1) {
   matches_.clear();
@@ skipping 385 matching lines @@
         &match.contents_class);
   }
   match.description = info.title();
   AutocompleteMatch::ClassifyMatchInString(params->input.text(),
                                            info.title(),
                                            ACMatchClassification::NONE,
                                            &match.description_class);
 
   return match;
 }