Omnibox: Create Bundled Field Trial; Convert SearchHistory trial to it

chrome/browser/autocomplete/search_provider.cc

 // Copyright 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/search_provider.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/callback.h"
@@ skipping 233 matching lines @@
 const char SearchProvider::kFalse[] = "false";
 
 SearchProvider::SearchProvider(AutocompleteProviderListener* listener,
                                Profile* profile)
     : AutocompleteProvider(listener, profile,
           AutocompleteProvider::TYPE_SEARCH),
       providers_(TemplateURLServiceFactory::GetForProfile(profile)),
       suggest_results_pending_(0),
       field_trial_triggered_(false),
       field_trial_triggered_in_session_(false),
-      omnibox_start_margin_(-1),
-      prevent_search_history_inlining_(
-          OmniboxFieldTrial::SearchHistoryPreventInlining()),
-      disable_search_history_(
-          OmniboxFieldTrial::SearchHistoryDisable()) {
+      omnibox_start_margin_(-1) {
 }
 
 // static
 AutocompleteMatch SearchProvider::CreateSearchSuggestion(
     AutocompleteProvider* autocomplete_provider,
     int relevance,
     AutocompleteMatch::Type type,
     const TemplateURL* template_url,
     const string16& query_string,
     const string16& input_text,
@@ skipping 354 matching lines @@
 
 void SearchProvider::DoHistoryQuery(bool minimal_changes) {
   // The history query results are synchronous, so if minimal_changes is true,
   // we still have the last results and don't need to do anything.
   if (minimal_changes)
     return;
 
   keyword_history_results_.clear();
   default_history_results_.clear();
 
-  if (disable_search_history_)
+  if (OmniboxFieldTrial::SearchHistoryDisable(
+      input_.current_page_classification()))

[Alexei Svitkine (slow), 2013/08/02 15:25:34]

Peter, can you explain why this should be indented differently then e.g. line
1205? Or even e.g. line 287.

I thought the rule was to indent 4 more whenever you wrap, unless aligning with
the same type of thing on the previous line.

[Peter Kasting, 2013/08/02 18:17:55]

It's not indented differently.  You indent 4 from the beginning of the previous
line, not from the beginning of the subexpression.

Also, you don't necessarily indent an additional 4 each time you wrap, you
indent only when the start of the previous line was at a different subexpression
level.  For example, "a + b + c", with long a/b/c, should be:

a +
    b +
    c;

Not

a +
    b +
        c;

     return;
 
   HistoryService* const history_service =
       HistoryServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);
   history::URLDatabase* url_db = history_service ?
       history_service->InMemoryDatabase() : NULL;
   if (!url_db)
     return;
 
   // Request history for both the keyword and default provider.  We grab many
@@ skipping 552 matching lines @@
 
 SearchProvider::SuggestResults SearchProvider::ScoreHistoryResults(
     const HistoryResults& results,
     bool base_prevent_inline_autocomplete,
     bool input_multiple_words,
     const string16& input_text,
     bool is_keyword) {
   AutocompleteClassifier* classifier =
       AutocompleteClassifierFactory::GetForProfile(profile_);
   SuggestResults scored_results;
+  const bool prevent_search_history_inlining =
+      OmniboxFieldTrial::SearchHistoryPreventInlining(
+          input_.current_page_classification());
   for (HistoryResults::const_iterator i(results.begin()); i != results.end();
        ++i) {
     // Don't autocomplete multi-word queries that have only been seen once
     // unless the user has typed more than one word.
     bool prevent_inline_autocomplete = base_prevent_inline_autocomplete ||
         (!input_multiple_words && (i->visits < 2) && HasMultipleWords(i->term));
 
     // Don't autocomplete search terms that would normally be treated as URLs
     // when typed. For example, if the user searched for "google.com" and types
     // "goog", don't autocomplete to the search term "google.com". Otherwise,
     // the input will look like a URL but act like a search, which is confusing.
     // NOTE: We don't check this in the following cases:
     //  * When inline autocomplete is disabled, we won't be inline
     //    autocompleting this term, so we don't need to worry about confusion as
     //    much.  This also prevents calling Classify() again from inside the
     //    classifier (which will corrupt state and likely crash), since the
     //    classifier always disables inline autocomplete.
     //  * When the user has typed the whole term, the "what you typed" history
     //    match will outrank us for URL-like inputs anyway, so we need not do
     //    anything special.
     if (!prevent_inline_autocomplete && classifier && (i->term != input_text)) {
       AutocompleteMatch match;
       classifier->Classify(i->term, false, false, &match, NULL);
       prevent_inline_autocomplete =
           !AutocompleteMatch::IsSearchType(match.type);
     }
 
-    int relevance = CalculateRelevanceForHistory(i->time, is_keyword,
-                                                 prevent_inline_autocomplete);
+    int relevance = CalculateRelevanceForHistory(
+        i->time, is_keyword, !prevent_inline_autocomplete,
+        prevent_search_history_inlining);
     scored_results.push_back(
         SuggestResult(i->term, is_keyword, relevance, false));
   }
 
   // History returns results sorted for us.  However, we may have docked some
   // results' scores, so things are no longer in order.  Do a stable sort to get
   // things back in order without otherwise disturbing results with equal
   // scores, then force the scores to be unique, so that the order in which
   // they're shown is deterministic.
   std::stable_sort(scored_results.begin(), scored_results.end(),
@@ skipping 84 matching lines @@
     *relevance_from_server = use_server_relevance;
   return use_server_relevance ?
       keyword_results_.verbatim_relevance :
       CalculateRelevanceForKeywordVerbatim(keyword_input_.type(),
                                            keyword_input_.prefer_keyword());
 }
 
 int SearchProvider::CalculateRelevanceForHistory(
     const base::Time& time,
     bool is_keyword,
-    bool prevent_inline_autocomplete) const {
+    bool use_aggressive_method,
+    bool prevent_search_history_inlining) const {
   // The relevance of past searches falls off over time. There are two distinct
   // equations used. If the first equation is used (searches to the primary
-  // provider that we want to inline autocomplete), the score is in the range
-  // 1300-1599 (unless |prevent_search_history_inlining_|, in which case
+  // provider that we want to score aggressively), the score is in the range
+  // 1300-1599 (unless |prevent_search_history_inlining|, in which case
   // it's in the range 1200-1299). If the second equation is used the
   // relevance of a search 15 minutes ago is discounted 50 points, while the
   // relevance of a search two weeks ago is discounted 450 points.
   double elapsed_time = std::max((base::Time::Now() - time).InSecondsF(), 0.0);
   bool is_primary_provider = is_keyword || !providers_.has_keyword_provider();
-  if (is_primary_provider && !prevent_inline_autocomplete) {
+  if (is_primary_provider && use_aggressive_method) {
     // Searches with the past two days get a different curve.
     const double autocomplete_time = 2 * 24 * 60 * 60;
     if (elapsed_time < autocomplete_time) {
       int max_score = is_keyword ? 1599 : 1399;
-      if (prevent_search_history_inlining_)
+      if (prevent_search_history_inlining)
         max_score = 1299;
       return max_score - static_cast<int>(99 *
           std::pow(elapsed_time / autocomplete_time, 2.5));
     }
     elapsed_time -= autocomplete_time;
   }
 
   const int score_discount =
       static_cast<int>(6.5 * std::pow(elapsed_time, 0.3));
 
@@ skipping 149 matching lines @@
     it->set_relevance(max_query_relevance);
     it->set_relevance_from_server(relevance_from_server);
   }
 }
 
 void SearchProvider::UpdateDone() {
   // We're done when the timer isn't running, there are no suggest queries
   // pending, and we're not waiting on Instant.
   done_ = !timer_.IsRunning() && (suggest_results_pending_ == 0);
 }