Add a command-line flag for overriding variations country.

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>
+#include <vector>
 
 #include "base/build_time.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
@@ skipping 308 matching lines @@
   }
 
   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);
 
-  const std::string latest_country =
-      local_state_->GetString(prefs::kVariationsCountry);
-
+  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
   // components should not depends on //ui/base.
   variations::VariationsSeedProcessor().CreateTrialsFromSeed(
       seed, client_->GetApplicationLocale(),
       GetReferenceDateForExpiryChecks(local_state_), current_version, channel,
       GetCurrentFormFactor(), GetHardwareClass(), latest_country,
@@ skipping 421 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 =
-      local_state_->GetString(prefs::kVariationsCountry);
+  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));
 
   UMA_HISTOGRAM_COUNTS_100("Variations.SimulateSeed.NormalChanges",
                            result.normal_group_change_count);
@@ skipping 21 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   return seed_store_.GetInvalidSignature();
 }
 
 std::string VariationsService::LoadPermanentConsistencyCountry(
     const base::Version& version,
     const std::string& latest_country) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(version.IsValid());
 
+  const std::string override_country =
+      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+          switches::kVariationsOverrideCountry);
+  if (!override_country.empty())
+    return override_country;
+
   const base::ListValue* list_value =
       local_state_->GetList(prefs::kVariationsPermanentConsistencyCountry);
   std::string stored_version_string;
   std::string stored_country;
 
   // Determine if the saved pref value is present and valid.
   const bool is_pref_empty = list_value->empty();
   const bool is_pref_valid = list_value->GetSize() == 2 &&
                              list_value->GetString(0, &stored_version_string) &&
                              list_value->GetString(1, &stored_country) &&
@@ skipping 87 matching lines @@
 
   if (got_stored_country && stored_country == country_override)
     return false;
 
   base::Version version(version_info::GetVersionNumber());
   StorePermanentCountry(version, country_override);
   return true;
 }
 
 std::string VariationsService::GetLatestCountry() const {
-  return local_state_->GetString(prefs::kVariationsCountry);
+  const std::string override_country =
+      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+          switches::kVariationsOverrideCountry);
+  return !override_country.empty()
+             ? override_country
+             : local_state_->GetString(prefs::kVariationsCountry);
 }
 
 }  // namespace variations