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 46 matching lines @@
 }
 
 }  // namespace
 
 VariationsSeedProcessor::VariationsSeedProcessor() {
 }
 
 VariationsSeedProcessor::~VariationsSeedProcessor() {
 }
 
+bool VariationsSeedProcessor::AllowVariationIdWithForcingFlag(

[Alexei Svitkine (slow), 2013/11/14 16:54:15]

This and the other function can just be free-standing functions in the anon
namespace at the top of the file.

[yao, 2013/11/14 20:51:12]

Done.

+    const Study& study) {
+  if (!study.has_filter())
+    return false;
+  Study_Filter filter = study.filter();
+  if (filter.platform_size() == 0 || filter.channel_size() == 0) {

[Alexei Svitkine (slow), 2013/11/14 16:54:15]

This doesn't need {}'s. (single line if and single line body)

[yao, 2013/11/14 20:51:12]

Done.

+    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)

[Alexei Svitkine (slow), 2013/11/14 16:54:15]

This does need {}'s - multi-line if. (Same below).

[yao, 2013/11/14 20:51:12]

Done.

+      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 126 matching lines @@
   }
 
   if (filter.has_max_version()) {
     if (version.CompareToWildcardString(filter.max_version()) > 0)
       return false;
   }
 
   return true;
 }
 
+void VariationsSeedProcessor::CheckVariationId(

[Alexei Svitkine (slow), 2013/11/14 16:54:15]

This should be called RegisterVariationIds().

[yao, 2013/11/14 20:51:12]

Done.

+    const Study_Experiment& experiment,
+    const std::string&  trial_name) {
+    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);
+    }
+}
+
 void VariationsSeedProcessor::CreateTrialFromStudy(
     const ProcessedStudy& processed_study) {
   const Study& study = *processed_study.study;
+  bool allowBoth = AllowVariationIdWithForcingFlag(study);

[Alexei Svitkine (slow), 2013/11/14 16:54:15]

Can we do this check lazily? (e.g. block below when we create the trial for the
forced flag?

That way, if there's 100 studies, we only do the check when necessary.

[yao, 2013/11/14 20:51:12]

Done.

 
   // Check if any experiments need to be forced due to a command line
   // 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 (allowBoth) {
+        CheckVariationId(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;
@@ skipping 10 matching lines @@
           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.
-    if (experiment.has_forcing_flag())
+    if (experiment.has_forcing_flag() && !allowBoth)

[Alexei Svitkine (slow), 2013/11/14 16:54:15]

I think we don't need this logic in this case. It's fine not registering the ids
except for the selected group.

[yao, 2013/11/14 20:51:12]

Done.

       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);
-    }
+    CheckVariationId(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