Omnibox: Create DemoteByType Experiment

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_split.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 kBundledExperimentFieldTrialName[] = "OmniboxBundledExperimentV1";
 
 // Rule names used by the bundled experiment.
 const char kSearchHistoryRule[] = "SearchHistory";
+const char kDemoteByTypeRule[] = "DemoteByType";
 
 // 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 187 matching lines @@
   return OmniboxFieldTrial::GetValueForRuleInContext(
       kSearchHistoryRule, current_page_classification) == "PreventInlining";
 }
 
 bool OmniboxFieldTrial::SearchHistoryDisable(
     AutocompleteInput::PageClassification current_page_classification) {
   return OmniboxFieldTrial::GetValueForRuleInContext(
       kSearchHistoryRule, current_page_classification) == "Disable";
 }
 
+void OmniboxFieldTrial::GetDemotionsByType(
+    AutocompleteInput::PageClassification current_page_classification,
+    DemotionMultiplierByType* demotions_by_type) {
+  demotions_by_type->clear();
+  const std::string demotion_rule =
+      OmniboxFieldTrial::GetValueForRuleInContext(
+          kDemoteByTypeRule,
+          current_page_classification);
+  // The value of the DemoteByType rule is a comma-separated list of
+  // {ResultType + ":" + Number} where ResultType is an AutocompleteMatchType::
+  // Type enum represented as an integer and Number is an integer number
+  // between 0 and 100 inclusive.   Relevance scores of matches of that result
+  // type are multiplied by Number / 100.  100 means no change.
+  std::vector<std::pair<std::string, std::string> > kv_pairs;

[Peter Kasting, 2013/08/06 19:33:50]

Nit: This suggests that string_split.h should have a typedef for this

[Mark P, 2013/08/06 22:00:15]

Done.

+  if (base::SplitStringIntoKeyValuePairs(demotion_rule, ':', ',', &kv_pairs)) {
+    for (size_t i = 0; i < kv_pairs.size(); ++i) {
+      // This is a best-effort conversion; we trust the hand-crafted parameters
+      // downloaded from the server to be perfect.  There's no need for handle
+      // errors smartly.
+      int k, v;
+      base::StringToInt(kv_pairs[i].first, &k);
+      base::StringToInt(kv_pairs[i].second, &v);
+      (*demotions_by_type)[static_cast<AutocompleteMatchType::Type>(k)] =
+          static_cast<float>(v) / 100.0f;
+    }
+  }
+}
+
 // 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=<Rule>:<AutocompleteInput::PageClassification (as an int)>
 //   value=<arbitrary string>
 // The AutocompleteInput::PageClassification can also be "*", which means
 // this rule applies in all page classification contexts.
@@ skipping 18 matching lines @@
   // Look up rule in this exact context.
   std::map<std::string, std::string>::iterator it =
       params.find(rule + ":" + base::IntToString(
           static_cast<int>(page_classification)));
   if (it != params.end())
     return it->second;
   // Look up rule in the global context.
   it = params.find(rule + ":*");
   return (it != params.end()) ? it->second : std::string();
 }