Introduce (Chrome)VariationsServiceClient

chrome/browser/metrics/variations/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 "chrome/browser/metrics/variations/variations_service.h"
 
 #include "base/build_time.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
@@ skipping 225 matching lines @@
   if (resource_id == -1)
     return;
 
   ui::ResourceBundle::GetSharedInstance().OverrideLocaleStringResource(
       resource_id, string);
 }
 
 }  // namespace
 
 VariationsService::VariationsService(
+    scoped_ptr<VariationsServiceClient> client,
     web_resource::ResourceRequestAllowedNotifier* notifier,
     PrefService* local_state,
     metrics::MetricsStateManager* state_manager)
-    : local_state_(local_state),
+    : client_(client.Pass()),
+      local_state_(local_state),
       state_manager_(state_manager),
       policy_pref_service_(local_state),
       seed_store_(local_state),
       create_trials_from_seed_called_(false),
       initial_request_completed_(false),
       disable_deltas_for_next_request_(false),
       resource_request_allowed_notifier_(notifier),
       request_count_(0),
       weak_ptr_factory_(this) {
   resource_request_allowed_notifier_->Init(this);
@@ skipping 14 matching lines @@
   const base::Version current_version(version_info::GetVersionNumber());
   if (!current_version.IsValid())
     return false;
 
   variations::Study_Channel channel = GetChannelForVariations();
   UMA_HISTOGRAM_SPARSE_SLOWLY("Variations.UserChannel", channel);
 
   const std::string latest_country =
       local_state_->GetString(prefs::kVariationsCountry);
   variations::VariationsSeedProcessor().CreateTrialsFromSeed(
-      seed, g_browser_process->GetApplicationLocale(),
+      seed, client_->GetApplicationLocale(),
       GetReferenceDateForExpiryChecks(local_state_), current_version, channel,
       GetCurrentFormFactor(), GetHardwareClass(), latest_country,
       LoadPermanentConsistencyCountry(current_version, latest_country),
       base::Bind(&OverrideUIString));
 
   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.
   const int64 last_fetch_time_internal =
@@ skipping 146 matching lines @@
 void VariationsService::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   // This preference will only be written by the policy service, which will fill
   // it according to a value stored in the User Policy.
   registry->RegisterStringPref(prefs::kVariationsRestrictParameter,
                                std::string());
 }
 
 // static
 scoped_ptr<VariationsService> VariationsService::Create(
+    scoped_ptr<VariationsServiceClient> client,
     PrefService* local_state,
     metrics::MetricsStateManager* state_manager) {
   scoped_ptr<VariationsService> result;
 #if !defined(GOOGLE_CHROME_BUILD)
   // Unless the URL was provided, unsupported builds should return NULL to
   // indicate that the service should not be used.
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kVariationsServerURL)) {
     DVLOG(1) << "Not creating VariationsService in unofficial build without --"
              << switches::kVariationsServerURL << " specified.";
     return result.Pass();
   }
 #endif
   result.reset(new VariationsService(
-      new web_resource::ResourceRequestAllowedNotifier(
-          local_state, switches::kDisableBackgroundNetworking),
+      client.Pass(), new web_resource::ResourceRequestAllowedNotifier(
+                         local_state, switches::kDisableBackgroundNetworking),
       local_state, state_manager));
   return result.Pass();
 }
 
 void VariationsService::DoActualFetch() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!pending_seed_request_);
 
   pending_seed_request_ = net::URLFetcher::Create(0, variations_server_url_,
                                                   net::URLFetcher::GET, this);
@@ skipping 194 matching lines @@
   const base::ElapsedTimer timer;
 
   scoped_ptr<const base::FieldTrial::EntropyProvider> entropy_provider =
       state_manager_->CreateEntropyProvider();
   variations::VariationsSeedSimulator seed_simulator(*entropy_provider);
 
   const std::string latest_country =
       local_state_->GetString(prefs::kVariationsCountry);
   const variations::VariationsSeedSimulator::Result result =
       seed_simulator.SimulateSeedStudies(
-          *seed, g_browser_process->GetApplicationLocale(),
+          *seed, client_->GetApplicationLocale(),
           GetReferenceDateForExpiryChecks(local_state_), version,
           GetChannelForVariations(), GetCurrentFormFactor(), GetHardwareClass(),
           latest_country,
           LoadPermanentConsistencyCountry(version, latest_country));
 
   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",
@@ skipping 85 matching lines @@
   // Otherwise, update the pref with the current Chrome version and country.
   base::ListValue new_list_value;
   new_list_value.AppendString(version.GetString());
   new_list_value.AppendString(latest_country);
   local_state_->Set(prefs::kVariationsPermanentConsistencyCountry,
                     new_list_value);
   return latest_country;
 }
 
 }  // namespace chrome_variations