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