Refactor VariationsSeedProcessor to add ProcessedStudy struct.

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>
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/stl_util.h"
 #include "base/version.h"
+#include "components/variations/processed_study.h"
 #include "components/variations/variations_associated_data.h"
 
 namespace chrome_variations {
 
 namespace {
 
 Study_Platform GetCurrentPlatform() {
 #if defined(OS_WIN)
   return Study_Platform_PLATFORM_WINDOWS;
 #elif defined(OS_IOS)
@@ skipping 37 matching lines @@
 
 VariationsSeedProcessor::~VariationsSeedProcessor() {
 }
 
 void VariationsSeedProcessor::CreateTrialsFromSeed(
     const VariationsSeed& seed,
     const std::string& locale,
     const base::Time& reference_date,
     const base::Version& version,
     Study_Channel channel) {
+  std::vector<ProcessedStudy> filtered_studies;
+  FilterAndValidateStudies(seed, locale, reference_date, version, channel,
+                           &filtered_studies);
+
+  for (size_t i = 0; i < filtered_studies.size(); ++i)
+    CreateTrialFromStudy(filtered_studies[i]);
+}
+
+void VariationsSeedProcessor::FilterAndValidateStudies(
+    const VariationsSeed& seed,
+    const std::string& locale,
+    const base::Time& reference_date,
+    const base::Version& version,
+    Study_Channel channel,
+    std::vector<ProcessedStudy>* filtered_studies) {
   DCHECK(version.IsValid());
 
   // Add expired studies (in a disabled state) only after all the non-expired
   // studies have been added (and do not add an expired study if a corresponding
   // non-expired study got added). This way, if there's both an expired and a
   // non-expired study that applies, the non-expired study takes priority.
   std::set<std::string> created_studies;
   std::vector<const Study*> expired_studies;
 
   for (int i = 0; i < seed.study_size(); ++i) {
     const Study& study = seed.study(i);
     if (!ShouldAddStudy(study, locale, reference_date, version, channel))
       continue;
 
     if (IsStudyExpired(study, reference_date)) {
       expired_studies.push_back(&study);
-    } else {
-      CreateTrialFromStudy(study, false);
+    } else if (!ContainsKey(created_studies, study.name())) {
+      ValidateAndAddStudy(study, false, filtered_studies);
       created_studies.insert(study.name());
     }
   }
 
   for (size_t i = 0; i < expired_studies.size(); ++i) {
     if (!ContainsKey(created_studies, expired_studies[i]->name()))
-      CreateTrialFromStudy(*expired_studies[i], true);
+      ValidateAndAddStudy(*expired_studies[i], true, filtered_studies);
   }
 }
 
+void VariationsSeedProcessor::ValidateAndAddStudy(
+    const Study& study,
+    bool is_expired,
+    std::vector<ProcessedStudy>* filtered_studies) {
+  base::FieldTrial::Probability total_probability = 0;
+  if (!ValidateStudyAndComputeTotalProbability(study, &total_probability))
+    return;
+  filtered_studies->push_back(ProcessedStudy(&study, total_probability,
+                                              is_expired));
+}
+
 bool VariationsSeedProcessor::CheckStudyChannel(const Study_Filter& filter,
                                                 Study_Channel channel) {
   // An empty channel list matches all channels.
   if (filter.channel_size() == 0)
     return true;
 
   for (int i = 0; i < filter.channel_size(); ++i) {
     if (filter.channel(i) == channel)
       return true;
   }
@@ skipping 49 matching lines @@
   }
 
   if (filter.has_max_version()) {
     if (version.CompareToWildcardString(filter.max_version()) > 0)
       return false;
   }
 
   return true;
 }
 
-void VariationsSeedProcessor::CreateTrialFromStudy(const Study& study,
-                                                   bool is_expired) {
-  base::FieldTrial::Probability total_probability = 0;
-  if (!ValidateStudyAndComputeTotalProbability(study, &total_probability))
-    return;
+void VariationsSeedProcessor::CreateTrialFromStudy(
+    const ProcessedStudy& processed_study) {
+  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.
   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);
@@ skipping 11 matching lines @@
     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(), total_probability, study.default_experiment_name(),
+          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.
     if (experiment.has_forcing_flag())
@@ skipping 14 matching lines @@
       const VariationID variation_id =
           static_cast<VariationID>(experiment.google_update_experiment_id());
       AssociateGoogleVariationIDForce(GOOGLE_UPDATE_SERVICE,
                                       study.name(),
                                       experiment.name(),
                                       variation_id);
     }
   }
 
   trial->SetForced();
-  if (is_expired)
+  if (processed_study.is_expired)
     trial->Disable();
   else if (study.activation_type() == Study_ActivationType_ACTIVATION_AUTO)
     trial->group();
 }
 
 bool VariationsSeedProcessor::IsStudyExpired(const Study& study,
                                        const base::Time& date_time) {
   if (study.has_expiry_date()) {
     const base::Time expiry_date =
         ConvertStudyDateToBaseTime(study.expiry_date());
@@ skipping 90 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