Allow variation id with forcing flag for special setup & unit tests.

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 <map>
 #include <set>
 #include <vector>
 
@@ skipping 38 matching lines @@
                               const Study_Experiment& experiment) {
   std::map<std::string, std::string> params;
   for (int i = 0; i < experiment.param_size(); ++i) {
     if (experiment.param(i).has_name() && experiment.param(i).has_value())
       params[experiment.param(i).name()] = experiment.param(i).value();
   }
   if (!params.empty())
     AssociateVariationParams(study.name(), experiment.name(), params);
 }
 
+// If if there is variation id associated with |experiment|, register the
+// variation id.
+void RegisterVariationIds(const Study_Experiment& experiment,
+                          const std::string&  trial_name) {

[Alexei Svitkine (slow), 2013/11/14 22:34:33]

Nit: Remove extra space before trial_name

[yao, 2013/11/14 23:41:15]

Done.

+    if (experiment.has_google_web_experiment_id()) {
+      const VariationID variation_id =
+          static_cast<VariationID>(experiment.google_web_experiment_id());
+      AssociateGoogleVariationIDForce(GOOGLE_WEB_PROPERTIES,
+                                      trial_name,
+                                      experiment.name(),
+                                      variation_id);
+    }
+    if (experiment.has_google_update_experiment_id()) {
+      const VariationID variation_id =
+          static_cast<VariationID>(experiment.google_update_experiment_id());
+      AssociateGoogleVariationIDForce(GOOGLE_UPDATE_SERVICE,
+                                      trial_name,
+                                      experiment.name(),
+                                      variation_id);
+    }
+}
+
 }  // namespace
 
 VariationsSeedProcessor::VariationsSeedProcessor() {
 }
 
 VariationsSeedProcessor::~VariationsSeedProcessor() {
 }
 
+bool VariationsSeedProcessor::AllowVariationIdWithForcingFlag(
+    const Study& study) {
+  if (!study.has_filter())
+    return false;
+  Study_Filter filter = study.filter();

[Alexei Svitkine (slow), 2013/11/14 22:34:33]

This does a copy. Use a reference (const Study_Filter& filter).

[yao, 2013/11/14 23:41:15]

Done.

+  if (filter.platform_size() == 0 || filter.channel_size() == 0)
+    return false;
+  for (int i = 0; i < filter.platform_size(); ++i) {
+    if (filter.platform(i) != Study_Platform_PLATFORM_ANDROID &&
+        filter.platform(i) != Study_Platform_PLATFORM_IOS) {
+      return false;
+    }
+  }
+  for (int i = 0; i < filter.channel_size(); ++i) {
+    if (filter.channel(i) != Study_Channel_CANARY &&
+        filter.channel(i) != Study_Channel_DEV) {
+      return false;
+    }
+  }
+  return true;
+}
+
 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) {
   std::vector<ProcessedStudy> filtered_studies;
   FilterAndValidateStudies(seed, locale, reference_date, version, channel,
                            form_factor, &filtered_studies);
@@ skipping 141 matching lines @@
   // flag. Force the first experiment with an existing flag.
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   for (int i = 0; i < study.experiment_size(); ++i) {
     const Study_Experiment& experiment = study.experiment(i);
     if (experiment.has_forcing_flag() &&
         command_line->HasSwitch(experiment.forcing_flag())) {
       base::FieldTrialList::CreateFieldTrial(study.name(), experiment.name());
       RegisterExperimentParams(study, experiment);
       DVLOG(1) << "Trial " << study.name() << " forced by flag: "
                << experiment.forcing_flag();
+      if (AllowVariationIdWithForcingFlag(study)) {

[Alexei Svitkine (slow), 2013/11/14 22:34:33]

No need for {}'s.

[yao, 2013/11/14 23:41:15]

Done.

+        RegisterVariationIds(experiment, study.name());
+      }
       return;
     }
   }
 
   uint32 randomization_seed = 0;
   base::FieldTrial::RandomizationType randomization_type =
       base::FieldTrial::SESSION_RANDOMIZED;
   if (study.has_consistency() &&
       study.consistency() == Study_Consistency_PERMANENT) {
     randomization_type = base::FieldTrial::ONE_TIME_RANDOMIZED;
     if (study.has_randomization_seed())
       randomization_seed = study.randomization_seed();
   }
 
   // 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));
 
   for (int i = 0; i < study.experiment_size(); ++i) {
     const Study_Experiment& experiment = study.experiment(i);
     RegisterExperimentParams(study, experiment);
 
-    // Groups with flags can't be selected randomly, so we don't add them to
-    // the field trial.
+    // 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())
       continue;
 
     if (experiment.name() != study.default_experiment_name())
       trial->AppendGroup(experiment.name(), experiment.probability_weight());
 
-    if (experiment.has_google_web_experiment_id()) {
-      const VariationID variation_id =
-          static_cast<VariationID>(experiment.google_web_experiment_id());
-      AssociateGoogleVariationIDForce(GOOGLE_WEB_PROPERTIES,
-                                      study.name(),
-                                      experiment.name(),
-                                      variation_id);
-    }
-    if (experiment.has_google_update_experiment_id()) {
-      const VariationID variation_id =
-          static_cast<VariationID>(experiment.google_update_experiment_id());
-      AssociateGoogleVariationIDForce(GOOGLE_UPDATE_SERVICE,
-                                      study.name(),
-                                      experiment.name(),
-                                      variation_id);
-    }
+    RegisterVariationIds(experiment, study.name());
   }
 
   trial->SetForced();
   if (processed_study.is_expired)
     trial->Disable();
   else if (study.activation_type() == Study_ActivationType_ACTIVATION_AUTO)
     trial->group();
 }
 
 bool VariationsSeedProcessor::IsStudyExpired(const Study& study,
@@ skipping 101 matching lines @@
     // The default group was not found in the list of groups. This study is not
     // valid.
     return false;
   }
 
   *total_probability = divisor;
   return true;
 }
 
 }  // namespace chrome_variations