components/variations/variations_seed_processor.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/variations/variations_seed_processor.h"
   6
   7 #include <map>
   8 #include <vector>
   9
  10 #include "base/command_line.h"
  11 #include "base/metrics/field_trial.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "components/variations/processed_study.h"
  14 #include "components/variations/study_filtering.h"
  15 #include "components/variations/variations_associated_data.h"
  16
  17 namespace variations {
  18
  19 namespace {
  20
  21 // Associates the variations params of |experiment|, if present.
  22 void RegisterExperimentParams(const Study& study,
  23                               const Study_Experiment& experiment) {
  24   std::map<std::string, std::string> params;
  25   for (int i = 0; i < experiment.param_size(); ++i) {
  26     if (experiment.param(i).has_name() && experiment.param(i).has_value())
  27       params[experiment.param(i).name()] = experiment.param(i).value();
  28   }
  29   if (!params.empty())
  30     AssociateVariationParams(study.name(), experiment.name(), params);
  31 }
  32
  33 // If there are variation ids associated with |experiment|, register the
  34 // variation ids.
  35 void RegisterVariationIds(const Study_Experiment& experiment,
  36                           const std::string& trial_name) {
  37   if (experiment.has_google_web_experiment_id()) {
  38     const VariationID variation_id =
  39         static_cast<VariationID>(experiment.google_web_experiment_id());
  40     AssociateGoogleVariationIDForce(GOOGLE_WEB_PROPERTIES,
  41                                     trial_name,
  42                                     experiment.name(),
  43                                     variation_id);
  44   }
  45   if (experiment.has_google_web_trigger_experiment_id()) {
  46     const VariationID variation_id =
  47         static_cast<VariationID>(experiment.google_web_trigger_experiment_id());
  48     AssociateGoogleVariationIDForce(GOOGLE_WEB_PROPERTIES_TRIGGER,
  49                                     trial_name,
  50                                     experiment.name(),
  51                                     variation_id);
  52   }
  53   if (experiment.has_google_update_experiment_id()) {
  54     const VariationID variation_id =
  55         static_cast<VariationID>(experiment.google_update_experiment_id());
  56     AssociateGoogleVariationIDForce(GOOGLE_UPDATE_SERVICE,
  57                                     trial_name,
  58                                     experiment.name(),
  59                                     variation_id);
  60   }
  61 }
  62
  63 // Executes |callback| on every override defined by |experiment|.
  64 void ApplyUIStringOverrides(
  65     const Study_Experiment& experiment,
  66     const VariationsSeedProcessor::UIStringOverrideCallback& callback) {
  67   for (int i = 0; i < experiment.override_ui_string_size(); ++i) {
  68     const Study_Experiment_OverrideUIString& override =
  69         experiment.override_ui_string(i);
  70     callback.Run(override.name_hash(), base::UTF8ToUTF16(override.value()));
  71   }
  72 }
  73
  74 }  // namespace
  75
  76 VariationsSeedProcessor::VariationsSeedProcessor() {
  77 }
  78
  79 VariationsSeedProcessor::~VariationsSeedProcessor() {
  80 }
  81
  82 void VariationsSeedProcessor::CreateTrialsFromSeed(
  83     const VariationsSeed& seed,
  84     const std::string& locale,
  85     const base::Time& reference_date,
  86     const base::Version& version,
  87     Study_Channel channel,
  88     Study_FormFactor form_factor,
  89     const std::string& hardware_class,
  90     const UIStringOverrideCallback& override_callback) {
  91   std::vector<ProcessedStudy> filtered_studies;
  92   FilterAndValidateStudies(seed, locale, reference_date, version, channel,
  93                            form_factor, hardware_class, &filtered_studies);
  94
  95   for (size_t i = 0; i < filtered_studies.size(); ++i)
  96     CreateTrialFromStudy(filtered_studies[i], override_callback);
  97 }
  98
  99 void VariationsSeedProcessor::CreateTrialFromStudy(
 100     const ProcessedStudy& processed_study,
 101     const UIStringOverrideCallback& override_callback) {
 102   const Study& study = *processed_study.study();
 103
 104   // Check if any experiments need to be forced due to a command line
 105   // flag. Force the first experiment with an existing flag.
 106   CommandLine* command_line = CommandLine::ForCurrentProcess();
 107   for (int i = 0; i < study.experiment_size(); ++i) {
 108     const Study_Experiment& experiment = study.experiment(i);
 109     if (experiment.has_forcing_flag() &&
 110         command_line->HasSwitch(experiment.forcing_flag())) {
 111       scoped_refptr<base::FieldTrial> trial(
 112           base::FieldTrialList::CreateFieldTrial(study.name(),
 113                                                  experiment.name()));
 114       RegisterExperimentParams(study, experiment);
 115       RegisterVariationIds(experiment, study.name());
 116       if (study.activation_type() == Study_ActivationType_ACTIVATION_AUTO) {
 117         trial->group();
 118         // UI Strings can only be overridden from ACTIVATION_AUTO experiments.
 119         ApplyUIStringOverrides(experiment, override_callback);
 120       }
 121
 122       DVLOG(1) << "Trial " << study.name() << " forced by flag: "
 123                << experiment.forcing_flag();
 124       return;
 125     }
 126   }
 127
 128   uint32 randomization_seed = 0;
 129   base::FieldTrial::RandomizationType randomization_type =
 130       base::FieldTrial::SESSION_RANDOMIZED;
 131   if (study.has_consistency() &&
 132       study.consistency() == Study_Consistency_PERMANENT) {
 133     randomization_type = base::FieldTrial::ONE_TIME_RANDOMIZED;
 134     if (study.has_randomization_seed())
 135       randomization_seed = study.randomization_seed();
 136   }
 137
 138   // The trial is created without specifying an expiration date because the
 139   // expiration check in field_trial.cc is based on the build date. Instead,
 140   // the expiration check using |reference_date| is done explicitly below.
 141   scoped_refptr<base::FieldTrial> trial(
 142       base::FieldTrialList::FactoryGetFieldTrialWithRandomizationSeed(
 143           study.name(), processed_study.total_probability(),
 144           study.default_experiment_name(),
 145           base::FieldTrialList::kNoExpirationYear, 1, 1, randomization_type,
 146           randomization_seed, NULL));
 147
 148   bool has_overrides = false;
 149   for (int i = 0; i < study.experiment_size(); ++i) {
 150     const Study_Experiment& experiment = study.experiment(i);
 151     RegisterExperimentParams(study, experiment);
 152
 153     // Groups with forcing flags have probability 0 and will never be selected.
 154     // Therefore, there's no need to add them to the field trial.
 155     if (experiment.has_forcing_flag())
 156       continue;
 157
 158     if (experiment.name() != study.default_experiment_name())
 159       trial->AppendGroup(experiment.name(), experiment.probability_weight());
 160
 161     RegisterVariationIds(experiment, study.name());
 162
 163     has_overrides = has_overrides || experiment.override_ui_string_size() > 0;
 164   }
 165
 166   trial->SetForced();
 167   if (processed_study.is_expired()) {
 168     trial->Disable();
 169   } else if (study.activation_type() == Study_ActivationType_ACTIVATION_AUTO) {
 170     const std::string& group_name = trial->group_name();
 171
 172     // Don't try to apply overrides if none of the experiments in this study had
 173     // any.
 174     if (!has_overrides)
 175       return;
 176
 177     // UI Strings can only be overridden from ACTIVATION_AUTO experiments.
 178     int experiment_index = processed_study.GetExperimentIndexByName(group_name);
 179
 180     // The field trial was defined from |study|, so the active experiment's name
 181     // must be in the |study|.
 182     DCHECK_NE(-1, experiment_index);
 183
 184     ApplyUIStringOverrides(study.experiment(experiment_index),
 185                            override_callback);
 186   }
 187 }
 188
 189 }  // namespace variations