Omnibox: Add Field Trial to Skip HistoryURL Provider Searching its Database

components/omnibox/browser/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 "components/omnibox/browser/history_url_provider.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 443 matching lines @@
       search_terms_data(new SearchTermsDataSnapshot(search_terms_data)) {
 }
 
 HistoryURLProviderParams::~HistoryURLProviderParams() {
 }
 
 HistoryURLProvider::HistoryURLProvider(AutocompleteProviderClient* client,
                                        AutocompleteProviderListener* listener)
     : HistoryProvider(AutocompleteProvider::TYPE_HISTORY_URL, client),
       listener_(listener),
-      params_(NULL) {
+      params_(NULL),
+      search_url_database_(OmniboxFieldTrial::HUPSearchDatabase()) {
   // Initialize the default HUP scoring params.
   OmniboxFieldTrial::GetDefaultHUPScoringParams(&scoring_params_);
   // Initialize HUP scoring params based on the current experiment.
   OmniboxFieldTrial::GetExperimentalHUPScoringParams(&scoring_params_);
 }
 
 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
@@ skipping 75 matching lines @@
     DoAutocomplete(NULL, url_db, params.get());
     matches_.clear();
     PromoteMatchesIfNecessary(*params);
     // NOTE: We don't reset |params| here since at least the |promote_type|
     // field on it will be read by the second pass -- see comments in
     // DoAutocomplete().
   }
 
   // Pass 2: Ask the history service to call us back on the history thread,
   // where we can read the full on-disk DB.
-  if (input.want_asynchronous_matches()) {
+  if (search_url_database_ && input.want_asynchronous_matches()) {
     done_ = false;
     params_ = params.release();  // This object will be destroyed in
                                  // QueryComplete() once we're done with it.
     history_service->ScheduleAutocomplete(
         base::Bind(&HistoryURLProvider::ExecuteWithDB, this, params_));
   }
 }
 
 void HistoryURLProvider::Stop(bool clear_cached_results,
                               bool due_to_user_inactivity) {
@@ skipping 134 matching lines @@
   return SpansFromTermMatch(
       description_matches, clean_description.length(), false);
 }
 
 void HistoryURLProvider::DoAutocomplete(history::HistoryBackend* backend,
                                         history::URLDatabase* db,
                                         HistoryURLProviderParams* params) {
   // Get the matching URLs from the DB.
   params->matches.clear();
   history::URLRows url_matches;
-  const URLPrefixes& prefixes = URLPrefix::GetURLPrefixes();
-  for (URLPrefixes::const_iterator i(prefixes.begin()); i != prefixes.end();
-       ++i) {
-    if (params->cancel_flag.IsSet())
-      return;  // Canceled in the middle of a query, give up.
 
-    // We only need kMaxMatches results in the end, but before we get there we
-    // need to promote lower-quality matches that are prefixes of higher-quality
-    // matches, and remove lower-quality redirects.  So we ask for more results
-    // than we need, of every prefix type, in hopes this will give us far more
-    // than enough to work with.  CullRedirects() will then reduce the list to
-    // the best kMaxMatches results.
-    db->AutocompleteForPrefix(
-        base::UTF16ToUTF8(i->prefix + params->input.text()), kMaxMatches * 2,
-        !backend, &url_matches);
-    for (history::URLRows::const_iterator j(url_matches.begin());
-          j != url_matches.end(); ++j) {
-      const URLPrefix* best_prefix = URLPrefix::BestURLPrefix(
-          base::UTF8ToUTF16(j->url().spec()), base::string16());
-      DCHECK(best_prefix);
-      params->matches.push_back(history::HistoryMatch(
-          *j, i->prefix.length(), !i->num_components,
-          i->num_components >= best_prefix->num_components));
+  if (search_url_database_) {
+    const URLPrefixes& prefixes = URLPrefix::GetURLPrefixes();
+    for (URLPrefixes::const_iterator i(prefixes.begin()); i != prefixes.end();
+         ++i) {
+      if (params->cancel_flag.IsSet())
+        return;  // Canceled in the middle of a query, give up.
+
+      // We only need kMaxMatches results in the end, but before we get there we
+      // need to promote lower-quality matches that are prefixes of higher-
+      // quality matches, and remove lower-quality redirects.  So we ask for
+      // more results than we need, of every prefix type, in hopes this will
+      // give us far more than enough to work with.  CullRedirects() will then
+      // reduce the list to the best kMaxMatches results.
+      db->AutocompleteForPrefix(
+          base::UTF16ToUTF8(i->prefix + params->input.text()), kMaxMatches * 2,
+          !backend, &url_matches);
+      for (history::URLRows::const_iterator j(url_matches.begin());
+           j != url_matches.end(); ++j) {
+        const URLPrefix* best_prefix = URLPrefix::BestURLPrefix(
+            base::UTF8ToUTF16(j->url().spec()), base::string16());
+        DCHECK(best_prefix);
+        params->matches.push_back(history::HistoryMatch(
+            *j, i->prefix.length(), !i->num_components,
+            i->num_components >= best_prefix->num_components));
+      }
     }
+
+    // Create sorted list of suggestions.
+    CullPoorMatches(params);
+    SortAndDedupMatches(&params->matches);
   }
 
-  // Create sorted list of suggestions.
-  CullPoorMatches(params);
-  SortAndDedupMatches(&params->matches);
-
   // Try to create a shorter suggestion from the best match.
   // We consider the what you typed match eligible for display when it's
   // navigable and there's a reasonable chance the user intended to do
   // something other than search.  We use a variety of heuristics to determine
   // this, e.g. whether the user explicitly typed a scheme, or if omnibox
   // searching has been disabled by policy. In the cases where we've parsed as
   // UNKNOWN, we'll still show an accidental search infobar if need be.
   VisitClassifier classifier(this, params->input, db);
   params->have_what_you_typed_match =
       (params->input.type() != metrics::OmniboxInputType::QUERY) &&
@@ skipping 445 matching lines @@
     AutocompleteMatch::ClassifyLocationInString(base::string16::npos, 0,
         match.contents.length(), ACMatchClassification::URL,
         &match.contents_class);
   }
   match.description = info.title();
   match.description_class =
       ClassifyDescription(params.input.text(), match.description);
   RecordAdditionalInfoFromUrlRow(info, &match);
   return match;
 }