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   if (experiment.has_chrome_sync_experiment_id()) {
  62     const VariationID variation_id =
  63         static_cast<VariationID>(experiment.chrome_sync_experiment_id());
  64     AssociateGoogleVariationIDForce(CHROME_SYNC_SERVICE,
  65                                     trial_name,
  66                                     experiment.name(),
  67                                     variation_id);
  68   }
  69 }
  70
  71 // Executes |callback| on every override defined by |experiment|.
  72 void ApplyUIStringOverrides(
  73     const Study_Experiment& experiment,
  74     const VariationsSeedProcessor::UIStringOverrideCallback& callback) {
  75   for (int i = 0; i < experiment.override_ui_string_size(); ++i) {
  76     const Study_Experiment_OverrideUIString& override =
  77         experiment.override_ui_string(i);
  78     callback.Run(override.name_hash(), base::UTF8ToUTF16(override.value()));
  79   }
  80 }
  81
  82 }  // namespace
  83
  84 VariationsSeedProcessor::VariationsSeedProcessor() {
  85 }
  86
  87 VariationsSeedProcessor::~VariationsSeedProcessor() {
  88 }
  89
  90 void VariationsSeedProcessor::CreateTrialsFromSeed(
  91     const VariationsSeed& seed,
  92     const std::string& locale,
  93     const base::Time& reference_date,
  94     const base::Version& version,
  95     Study_Channel channel,
  96     Study_FormFactor form_factor,
  97     const std::string& hardware_class,
  98     const UIStringOverrideCallback& override_callback) {
  99   std::vector<ProcessedStudy> filtered_studies;
 100   FilterAndValidateStudies(seed, locale, reference_date, version, channel,
 101                            form_factor, hardware_class, &filtered_studies);
 102
 103   for (size_t i = 0; i < filtered_studies.size(); ++i)
 104     CreateTrialFromStudy(filtered_studies[i], override_callback);
 105 }
 106
 107 void VariationsSeedProcessor::CreateTrialFromStudy(
 108     const ProcessedStudy& processed_study,
 109     const UIStringOverrideCallback& override_callback) {
 110   const Study& study = *processed_study.study();
 111
 112   // Check if any experiments need to be forced due to a command line
 113   // flag. Force the first experiment with an existing flag.
 114   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 115   for (int i = 0; i < study.experiment_size(); ++i) {
 116     const Study_Experiment& experiment = study.experiment(i);
 117     if (experiment.has_forcing_flag() &&
 118         command_line->HasSwitch(experiment.forcing_flag())) {
 119       scoped_refptr<base::FieldTrial> trial(
 120           base::FieldTrialList::CreateFieldTrial(study.name(),
 121                                                  experiment.name()));
 122       // If |trial| is NULL, then there might already be a trial forced to a
 123       // different group (e.g. via --force-fieldtrials). Break out of the loop,
 124       // but don't return, so that variation ids and params for the selected
 125       // group will still be picked up.
 126       if (!trial.get())
 127         break;
 128
 129       RegisterExperimentParams(study, experiment);
 130       RegisterVariationIds(experiment, study.name());
 131       if (study.activation_type() == Study_ActivationType_ACTIVATION_AUTO) {
 132         trial->group();
 133         // UI Strings can only be overridden from ACTIVATION_AUTO experiments.
 134         ApplyUIStringOverrides(experiment, override_callback);
 135       }
 136
 137       DVLOG(1) << "Trial " << study.name() << " forced by flag: "
 138                << experiment.forcing_flag();
 139       return;
 140     }
 141   }
 142
 143   uint32 randomization_seed = 0;
 144   base::FieldTrial::RandomizationType randomization_type =
 145       base::FieldTrial::SESSION_RANDOMIZED;
 146   if (study.has_consistency() &&
 147       study.consistency() == Study_Consistency_PERMANENT &&
 148       // If all assignments are to a single group, no need to enable one time
 149       // randomization (which is more expensive to compute), since the result
 150       // will be the same.
 151       !processed_study.all_assignments_to_one_group()) {
 152     randomization_type = base::FieldTrial::ONE_TIME_RANDOMIZED;
 153     if (study.has_randomization_seed())
 154       randomization_seed = study.randomization_seed();
 155   }
 156
 157   // The trial is created without specifying an expiration date because the
 158   // expiration check in field_trial.cc is based on the build date. Instead,
 159   // the expiration check using |reference_date| is done explicitly below.
 160   scoped_refptr<base::FieldTrial> trial(
 161       base::FieldTrialList::FactoryGetFieldTrialWithRandomizationSeed(
 162           study.name(), processed_study.total_probability(),
 163           study.default_experiment_name(),
 164           base::FieldTrialList::kNoExpirationYear, 1, 1, randomization_type,
 165           randomization_seed, NULL));
 166
 167   bool has_overrides = false;
 168   for (int i = 0; i < study.experiment_size(); ++i) {
 169     const Study_Experiment& experiment = study.experiment(i);
 170     RegisterExperimentParams(study, experiment);
 171
 172     // Groups with forcing flags have probability 0 and will never be selected.
 173     // Therefore, there's no need to add them to the field trial.
 174     if (experiment.has_forcing_flag())
 175       continue;
 176
 177     if (experiment.name() != study.default_experiment_name())
 178       trial->AppendGroup(experiment.name(), experiment.probability_weight());
 179
 180     RegisterVariationIds(experiment, study.name());
 181
 182     has_overrides = has_overrides || experiment.override_ui_string_size() > 0;
 183   }
 184
 185   trial->SetForced();
 186   if (processed_study.is_expired()) {
 187     trial->Disable();
 188   } else if (study.activation_type() == Study_ActivationType_ACTIVATION_AUTO) {
 189     const std::string& group_name = trial->group_name();
 190
 191     // Don't try to apply overrides if none of the experiments in this study had
 192     // any.
 193     if (!has_overrides)
 194       return;
 195
 196     // UI Strings can only be overridden from ACTIVATION_AUTO experiments.
 197     int experiment_index = processed_study.GetExperimentIndexByName(group_name);
 198
 199     // The field trial was defined from |study|, so the active experiment's name
 200     // must be in the |study|.
 201     DCHECK_NE(-1, experiment_index);
 202
 203     ApplyUIStringOverrides(study.experiment(experiment_index),
 204                            override_callback);
 205   }
 206 }
 207
 208 }  // namespace variations