Use low entropy for studies that send experiment IDs to Google properties.

components/variations/variations_seed_processor.cc

 // Copyright 2013 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 "components/variations/variations_seed_processor.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <vector>
@@ skipping 150 matching lines @@
   if (experiment.feature_association().has_forcing_feature_off()) {
     return feature_list.IsFeatureOverriddenFromCommandLine(
         experiment.feature_association().forcing_feature_off(),
         base::FeatureList::OVERRIDE_DISABLE_FEATURE);
   }
   if (experiment.has_forcing_flag())
     return command_line.HasSwitch(experiment.forcing_flag());
   return false;
 }
 
+bool ShouldStudyUseLowEntropy(const Study& study) {
+  for (int i = 0; i < study.experiment_size(); ++i) {
+    const Study_Experiment& experiment = study.experiment(i);
+    if (experiment.has_google_web_experiment_id() ||
+        experiment.has_google_web_trigger_experiment_id() ||
+        experiment.has_google_update_experiment_id() ||
+        experiment.has_chrome_sync_experiment_id()) {
+      return true;
+    }
+  }
+  return false;
+}
+
 }  // namespace
 
 VariationsSeedProcessor::VariationsSeedProcessor() {
 }
 
 VariationsSeedProcessor::~VariationsSeedProcessor() {
 }
 
 void VariationsSeedProcessor::CreateTrialsFromSeed(
     const VariationsSeed& seed,
     const std::string& locale,
     const base::Time& reference_date,
     const base::Version& version,
     Study_Channel channel,
     Study_FormFactor form_factor,
     const std::string& hardware_class,
     const std::string& session_consistency_country,
     const std::string& permanent_consistency_country,
     const UIStringOverrideCallback& override_callback,
-    base::FeatureList* feature_list) {
+    base::FeatureList* feature_list,
+    const base::FieldTrial::EntropyProvider* low_entropy_provider) {
   std::vector<ProcessedStudy> filtered_studies;
   FilterAndValidateStudies(seed, locale, reference_date, version, channel,
                            form_factor, hardware_class,
                            session_consistency_country,
                            permanent_consistency_country, &filtered_studies);
 
   for (size_t i = 0; i < filtered_studies.size(); ++i)
-    CreateTrialFromStudy(filtered_studies[i], override_callback, feature_list);
+    CreateTrialFromStudy(filtered_studies[i], override_callback, feature_list,
+                         low_entropy_provider);
 }
 
 void VariationsSeedProcessor::CreateTrialFromStudy(
     const ProcessedStudy& processed_study,
     const UIStringOverrideCallback& override_callback,
-    base::FeatureList* feature_list) {
+    base::FeatureList* feature_list,
+    const base::FieldTrial::EntropyProvider* low_entropy_provider) {
   const Study& study = *processed_study.study();
 
   // Check if any experiments need to be forced due to a command line
   // flag. Force the first experiment with an existing flag.
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   for (int i = 0; i < study.experiment_size(); ++i) {
     const Study_Experiment& experiment = study.experiment(i);
     if (ShouldForceExperiment(experiment, *command_line, *feature_list)) {
       base::FieldTrial* trial = base::FieldTrialList::CreateFieldTrial(
           study.name(), experiment.name());
@@ skipping 33 matching lines @@
   }
 
   // The trial is created without specifying an expiration date because the
   // expiration check in field_trial.cc is based on the build date. Instead,
   // the expiration check using |reference_date| is done explicitly below.
   scoped_refptr<base::FieldTrial> trial(
       base::FieldTrialList::FactoryGetFieldTrialWithRandomizationSeed(
           study.name(), processed_study.total_probability(),
           study.default_experiment_name(),
           base::FieldTrialList::kNoExpirationYear, 1, 1, randomization_type,
-          randomization_seed, NULL));
+          randomization_seed, NULL,
+          ShouldStudyUseLowEntropy(study) ? low_entropy_provider : NULL));
 
   bool has_overrides = false;
   bool enables_or_disables_features = false;
   for (int i = 0; i < study.experiment_size(); ++i) {
     const Study_Experiment& experiment = study.experiment(i);
     RegisterExperimentParams(study, experiment);
 
     // Groups with forcing flags have probability 0 and will never be selected.
     // Therefore, there's no need to add them to the field trial.
     if (experiment.has_forcing_flag() ||
@@ skipping 35 matching lines @@
     // The field trial was defined from |study|, so the active experiment's name
     // must be in the |study|.
     DCHECK_NE(-1, experiment_index);
 
     ApplyUIStringOverrides(study.experiment(experiment_index),
                            override_callback);
   }
 }
 
 }  // namespace variations