[Variations] Refactor all state used for study filtering into a container struct.

components/variations/service/variations_service.cc

 // Copyright (c) 2012 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/service/variations_service.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 315 matching lines @@
       RecordCreateTrialsSeedExpiry(VARIATIONS_SEED_EXPIRY_EXPIRED);
       return false;
     }
     RecordCreateTrialsSeedExpiry(VARIATIONS_SEED_EXPIRY_NOT_EXPIRED);
   }
 
   const base::Version current_version(version_info::GetVersionNumber());
   if (!current_version.IsValid())
     return false;
 
-  variations::Study_Channel channel =
-      GetChannelForVariations(client_->GetChannel());
-  UMA_HISTOGRAM_SPARSE_SLOWLY("Variations.UserChannel", channel);
+  std::unique_ptr<ClientFilterableState> client_state =
+      GetClientFilterableStateForVersion(current_version);
+  UMA_HISTOGRAM_SPARSE_SLOWLY("Variations.UserChannel", client_state->channel);
 
-  const std::string latest_country = GetLatestCountry();
   std::unique_ptr<const base::FieldTrial::EntropyProvider> low_entropy_provider(
       CreateLowEntropyProvider());
   // Note that passing |&ui_string_overrider_| via base::Unretained below is
   // safe because the callback is executed synchronously. It is not possible
-  // to pass UIStringOverrider itself to VariationSeedProcesor as variations
+  // to pass UIStringOverrider itself to VariationSeedProcessor as variations
   // components should not depends on //ui/base.
   variations::VariationsSeedProcessor().CreateTrialsFromSeed(
-      seed, client_->GetApplicationLocale(),
-      GetReferenceDateForExpiryChecks(local_state_), current_version, channel,
-      GetCurrentFormFactor(), GetHardwareClass(), latest_country,
-      LoadPermanentConsistencyCountry(current_version, latest_country),
+      seed, *client_state,
       base::Bind(&UIStringOverrider::OverrideUIString,
                  base::Unretained(&ui_string_overrider_)),
       low_entropy_provider.get(), feature_list);
 
   const base::Time now = base::Time::Now();
 
   // Log the "freshness" of the seed that was just used. The freshness is the
   // time between the last successful seed download and now.
   if (last_fetch_time_internal) {
     const base::TimeDelta delta =
@@ skipping 258 matching lines @@
 
 std::unique_ptr<const base::FieldTrial::EntropyProvider>
 VariationsService::CreateLowEntropyProvider() {
   return state_manager_->CreateLowEntropyProvider();
 }
 
 bool VariationsService::LoadSeed(VariationsSeed* seed) {
   return seed_store_.LoadSeed(seed);
 }
 
+std::unique_ptr<ClientFilterableState>
+VariationsService::GetClientFilterableStateForVersion(
+    const base::Version& version) {
+  std::unique_ptr<ClientFilterableState> state =
+      base::MakeUnique<ClientFilterableState>();
+  state->locale = client_->GetApplicationLocale();
+  state->reference_date = GetReferenceDateForExpiryChecks(local_state_);
+  state->version = version;
+  state->channel = GetChannelForVariations(client_->GetChannel());
+  state->form_factor = GetCurrentFormFactor();
+  state->platform = ClientFilterableState::GetCurrentPlatform();
+  state->hardware_class = GetHardwareClass();
+  state->session_consistency_country = GetLatestCountry();
+  state->permanent_consistency_country = LoadPermanentConsistencyCountry(
+      version, state->session_consistency_country);
+  return state;
+}
+
 void VariationsService::FetchVariationsSeed() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const web_resource::ResourceRequestAllowedNotifier::State state =
       resource_request_allowed_notifier_->GetResourceRequestsAllowedState();
   RecordRequestsAllowedHistogram(ResourceRequestStateToHistogramValue(state));
   if (state != web_resource::ResourceRequestAllowedNotifier::ALLOWED) {
     DVLOG(1) << "Resource requests were not allowed. Waiting for notification.";
     return;
   }
@@ skipping 124 matching lines @@
 
   const base::ElapsedTimer timer;
 
   std::unique_ptr<const base::FieldTrial::EntropyProvider> default_provider =
       state_manager_->CreateDefaultEntropyProvider();
   std::unique_ptr<const base::FieldTrial::EntropyProvider> low_provider =
       state_manager_->CreateLowEntropyProvider();
   variations::VariationsSeedSimulator seed_simulator(*default_provider,
                                                      *low_provider);
 
-  const std::string latest_country = GetLatestCountry();
-  const variations::VariationsSeedSimulator::Result result =
-      seed_simulator.SimulateSeedStudies(
-          *seed, client_->GetApplicationLocale(),
-          GetReferenceDateForExpiryChecks(local_state_), version,
-          GetChannelForVariations(client_->GetChannel()),
-          GetCurrentFormFactor(), GetHardwareClass(), latest_country,
-          LoadPermanentConsistencyCountry(version, latest_country));
+  std::unique_ptr<ClientFilterableState> client_state =
+      GetClientFilterableStateForVersion(version);
+  const VariationsSeedSimulator::Result result =
+      seed_simulator.SimulateSeedStudies(*seed, *client_state);
 
   UMA_HISTOGRAM_COUNTS_100("Variations.SimulateSeed.NormalChanges",
                            result.normal_group_change_count);
   UMA_HISTOGRAM_COUNTS_100("Variations.SimulateSeed.KillBestEffortChanges",
                            result.kill_best_effort_group_change_count);
   UMA_HISTOGRAM_COUNTS_100("Variations.SimulateSeed.KillCriticalChanges",
                            result.kill_critical_group_change_count);
 
   UMA_HISTOGRAM_TIMES("Variations.SimulateSeed.Duration", timer.Elapsed());
 
@@ skipping 136 matching lines @@
 std::string VariationsService::GetLatestCountry() const {
   const std::string override_country =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kVariationsOverrideCountry);
   return !override_country.empty()
              ? override_country
              : local_state_->GetString(prefs::kVariationsCountry);
 }
 
 }  // namespace variations