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

chrome/browser/omnibox/omnibox_field_trial.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/omnibox/omnibox_field_trial.h"
 
 #include <string>
 
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/common/metrics/metrics_util.h"
 #include "chrome/common/metrics/variations/variation_ids.h"
 #include "chrome/common/metrics/variations/variations_util.h"
 
 namespace {
 
 // Field trial names.
 const char kHUPCullRedirectsFieldTrialName[] = "OmniboxHUPCullRedirects";
 const char kHUPCreateShorterMatchFieldTrialName[] =
     "OmniboxHUPCreateShorterMatch";
 const char kStopTimerFieldTrialName[] = "OmniboxStopTimer";
 const char kShortcutsScoringFieldTrialName[] = "OmniboxShortcutsScoring";
-const char kSearchHistoryFieldTrialName[] = "OmniboxSearchHistory";
+const char kBundledExperimentFieldTrialName[] = "OmniboxBundledExperimentV1";
+
+// Rule names used by the bundled experiment.
+const char kSearchHistoryRule[] = "SearchHistory";
 
 // The autocomplete dynamic field trial name prefix.  Each field trial is
 // configured dynamically and is retrieved automatically by Chrome during
 // the startup.
 const char kAutocompleteDynamicFieldTrialPrefix[] = "AutocompleteDynamicTrial_";
 // The maximum number of the autocomplete dynamic field trials (aka layers).
 const int kMaxAutocompleteDynamicFieldTrials = 5;
 
 // Field trial experiment probabilities.
 
@@ skipping 175 matching lines @@
     return false;
   if (!base::StringToInt(base::StringPiece(
           group_name.substr(strlen(kMaxRelevanceGroupPrefix))),
                          max_relevance)) {
     LOG(WARNING) << "Malformed MaxRelevance string: " << group_name;
     return false;
   }
   return true;
 }
 
-bool OmniboxFieldTrial::SearchHistoryPreventInlining() {
-  return (base::FieldTrialList::FindFullName(kSearchHistoryFieldTrialName) ==
-          "PreventInlining");
+bool OmniboxFieldTrial::SearchHistoryPreventInlining(
+    AutocompleteInput::PageClassification current_page_classification) {
+  return OmniboxFieldTrial::GetConsequencesOfRuleInPageClassificationContext(
+      current_page_classification, kSearchHistoryRule) == "PreventInlining";
 }
 
-bool OmniboxFieldTrial::SearchHistoryDisable() {
-  return (base::FieldTrialList::FindFullName(kSearchHistoryFieldTrialName) ==
-          "Disable");
+bool OmniboxFieldTrial::SearchHistoryDisable(
+    AutocompleteInput::PageClassification current_page_classification) {
+  return OmniboxFieldTrial::GetConsequencesOfRuleInPageClassificationContext(
+      current_page_classification, kSearchHistoryRule) == "Disable";
 }
+
+// Background and implementation details:
+//
+// Each experiment group in any field trial can come with an optional set of
+// parameters (key-value pairs).  In the bundled omnibox experiment
+// (kBundledExperimentFieldTrialName), each experiment group comes with a
+// list of parameters in the form:
+//   key=<AutocompleteInput::PageClassification (as an int)>:<Rule>
+//   value=<Consequences>
+// The AutocompleteInput::PageClassification can also be "*", which means
+// this rule applies in all contexts.
+// One example parameter is
+//   key=6:SearchHistory
+//   value=PreventInlining
+// This means in context 6 (a search result page doing search term replacement),
+// the SearchHistory experience should PreventInlining.
+//
+// In short, this function tries to find the value associated with key
+// |current_page_classification|:|rule|, failing that it looks up
+// *:|rule|, and failing that it returns the empty string.
+std::string OmniboxFieldTrial::GetConsequencesOfRuleInPageClassificationContext(

[Mark P, 2013/07/30 21:00:29]

asvitkine: This function would be a little shorter if I could simply call
GetVariationParamValue() twice, but it can't tell the difference between an
empty value and a missing key.

+    AutocompleteInput::PageClassification current_page_classification,
+    const std::string& rule) {
+  std::map<std::string, std::string> params;
+  if (!chrome_variations::GetVariationParams(kBundledExperimentFieldTrialName,
+                                             &params)) {
+    return "";
+  }
+  // Lookup rule in this exact context.
+  std::map<std::string, std::string>::iterator it =
+      params.find(base::IntToString(
+          static_cast<int>(current_page_classification)) + ":" + rule);
+  if (it != params.end())
+    return it->second;
+  // Lookup rule in the global context.
+  it = params.find("*:" + rule);
+  if (it != params.end())
+    return it->second;
+  return "";
+}