Home | History | Annotate | Download | only in variations 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/metrics/variations/variations_service.h"
      6 
      7 #include <set>
      8 
      9 #include "base/build_time.h"
     10 #include "base/command_line.h"
     11 #include "base/metrics/histogram.h"
     12 #include "base/metrics/sparse_histogram.h"
     13 #include "base/prefs/pref_registry_simple.h"
     14 #include "base/prefs/pref_service.h"
     15 #include "base/sys_info.h"
     16 #include "base/task_runner_util.h"
     17 #include "base/timer/elapsed_timer.h"
     18 #include "base/version.h"
     19 #include "chrome/browser/browser_process.h"
     20 #include "chrome/common/chrome_switches.h"
     21 #include "chrome/common/pref_names.h"
     22 #include "components/metrics/metrics_state_manager.h"
     23 #include "components/network_time/network_time_tracker.h"
     24 #include "components/pref_registry/pref_registry_syncable.h"
     25 #include "components/variations/proto/variations_seed.pb.h"
     26 #include "components/variations/variations_seed_processor.h"
     27 #include "components/variations/variations_seed_simulator.h"
     28 #include "content/public/browser/browser_thread.h"
     29 #include "net/base/load_flags.h"
     30 #include "net/base/net_errors.h"
     31 #include "net/base/network_change_notifier.h"
     32 #include "net/base/url_util.h"
     33 #include "net/http/http_response_headers.h"
     34 #include "net/http/http_status_code.h"
     35 #include "net/http/http_util.h"
     36 #include "net/url_request/url_fetcher.h"
     37 #include "net/url_request/url_request_status.h"
     38 #include "ui/base/device_form_factor.h"
     39 #include "url/gurl.h"
     40 
     41 #if !defined(OS_ANDROID) && !defined(OS_IOS) && !defined(OS_CHROMEOS)
     42 #include "chrome/browser/upgrade_detector_impl.h"
     43 #endif
     44 
     45 #if defined(OS_CHROMEOS)
     46 #include "chrome/browser/chromeos/settings/cros_settings.h"
     47 #endif
     48 
     49 namespace chrome_variations {
     50 
     51 namespace {
     52 
     53 // Default server of Variations seed info.
     54 const char kDefaultVariationsServerURL[] =
     55     "https://clients4.google.com/chrome-variations/seed";
     56 const int kMaxRetrySeedFetch = 5;
     57 
     58 // TODO(mad): To be removed when we stop updating the NetworkTimeTracker.
     59 // For the HTTP date headers, the resolution of the server time is 1 second.
     60 const int64 kServerTimeResolutionMs = 1000;
     61 
     62 // Wrapper around channel checking, used to enable channel mocking for
     63 // testing. If the current browser channel is not UNKNOWN, this will return
     64 // that channel value. Otherwise, if the fake channel flag is provided, this
     65 // will return the fake channel. Failing that, this will return the UNKNOWN
     66 // channel.
     67 Study_Channel GetChannelForVariations() {
     68   switch (chrome::VersionInfo::GetChannel()) {
     69     case chrome::VersionInfo::CHANNEL_CANARY:
     70       return Study_Channel_CANARY;
     71     case chrome::VersionInfo::CHANNEL_DEV:
     72       return Study_Channel_DEV;
     73     case chrome::VersionInfo::CHANNEL_BETA:
     74       return Study_Channel_BETA;
     75     case chrome::VersionInfo::CHANNEL_STABLE:
     76       return Study_Channel_STABLE;
     77     case chrome::VersionInfo::CHANNEL_UNKNOWN:
     78       break;
     79   }
     80   const std::string forced_channel =
     81       CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
     82           switches::kFakeVariationsChannel);
     83   if (forced_channel == "stable")
     84     return Study_Channel_STABLE;
     85   if (forced_channel == "beta")
     86     return Study_Channel_BETA;
     87   if (forced_channel == "dev")
     88     return Study_Channel_DEV;
     89   if (forced_channel == "canary")
     90     return Study_Channel_CANARY;
     91   DVLOG(1) << "Invalid channel provided: " << forced_channel;
     92   return Study_Channel_UNKNOWN;
     93 }
     94 
     95 // Returns a string that will be used for the value of the 'osname' URL param
     96 // to the variations server.
     97 std::string GetPlatformString() {
     98 #if defined(OS_WIN)
     99   return "win";
    100 #elif defined(OS_IOS)
    101   return "ios";
    102 #elif defined(OS_MACOSX)
    103   return "mac";
    104 #elif defined(OS_CHROMEOS)
    105   return "chromeos";
    106 #elif defined(OS_ANDROID)
    107   return "android";
    108 #elif defined(OS_LINUX) || defined(OS_BSD) || defined(OS_SOLARIS)
    109   // Default BSD and SOLARIS to Linux to not break those builds, although these
    110   // platforms are not officially supported by Chrome.
    111   return "linux";
    112 #else
    113 #error Unknown platform
    114 #endif
    115 }
    116 
    117 // Gets the version number to use for variations seed simulation. Must be called
    118 // on a thread where IO is allowed.
    119 base::Version GetVersionForSimulation() {
    120 #if !defined(OS_ANDROID) && !defined(OS_IOS) && !defined(OS_CHROMEOS)
    121   const base::Version installed_version =
    122       UpgradeDetectorImpl::GetCurrentlyInstalledVersion();
    123   if (installed_version.IsValid())
    124     return installed_version;
    125 #endif  // !defined(OS_ANDROID) && !defined(OS_IOS) && !defined(OS_CHROMEOS)
    126 
    127   // TODO(asvitkine): Get the version that will be used on restart instead of
    128   // the current version on Android, iOS and ChromeOS.
    129   return base::Version(chrome::VersionInfo().Version());
    130 }
    131 
    132 // Gets the restrict parameter from |policy_pref_service| or from Chrome OS
    133 // settings in the case of that platform.
    134 std::string GetRestrictParameterPref(PrefService* policy_pref_service) {
    135   std::string parameter;
    136 #if defined(OS_CHROMEOS)
    137   chromeos::CrosSettings::Get()->GetString(
    138       chromeos::kVariationsRestrictParameter, &parameter);
    139 #else
    140   if (policy_pref_service) {
    141     parameter =
    142         policy_pref_service->GetString(prefs::kVariationsRestrictParameter);
    143   }
    144 #endif
    145   return parameter;
    146 }
    147 
    148 enum ResourceRequestsAllowedState {
    149   RESOURCE_REQUESTS_ALLOWED,
    150   RESOURCE_REQUESTS_NOT_ALLOWED,
    151   RESOURCE_REQUESTS_ALLOWED_NOTIFIED,
    152   RESOURCE_REQUESTS_NOT_ALLOWED_EULA_NOT_ACCEPTED,
    153   RESOURCE_REQUESTS_NOT_ALLOWED_NETWORK_DOWN,
    154   RESOURCE_REQUESTS_NOT_ALLOWED_COMMAND_LINE_DISABLED,
    155   RESOURCE_REQUESTS_ALLOWED_ENUM_SIZE,
    156 };
    157 
    158 // Records UMA histogram with the current resource requests allowed state.
    159 void RecordRequestsAllowedHistogram(ResourceRequestsAllowedState state) {
    160   UMA_HISTOGRAM_ENUMERATION("Variations.ResourceRequestsAllowed", state,
    161                             RESOURCE_REQUESTS_ALLOWED_ENUM_SIZE);
    162 }
    163 
    164 // Converts ResourceRequestAllowedNotifier::State to the corresponding
    165 // ResourceRequestsAllowedState value.
    166 ResourceRequestsAllowedState ResourceRequestStateToHistogramValue(
    167     ResourceRequestAllowedNotifier::State state) {
    168   switch (state) {
    169     case ResourceRequestAllowedNotifier::DISALLOWED_EULA_NOT_ACCEPTED:
    170       return RESOURCE_REQUESTS_NOT_ALLOWED_EULA_NOT_ACCEPTED;
    171     case ResourceRequestAllowedNotifier::DISALLOWED_NETWORK_DOWN:
    172       return RESOURCE_REQUESTS_NOT_ALLOWED_NETWORK_DOWN;
    173     case ResourceRequestAllowedNotifier::DISALLOWED_COMMAND_LINE_DISABLED:
    174       return RESOURCE_REQUESTS_NOT_ALLOWED_COMMAND_LINE_DISABLED;
    175     case ResourceRequestAllowedNotifier::ALLOWED:
    176       return RESOURCE_REQUESTS_ALLOWED;
    177   }
    178   NOTREACHED();
    179   return RESOURCE_REQUESTS_NOT_ALLOWED;
    180 }
    181 
    182 
    183 // Gets current form factor and converts it from enum DeviceFormFactor to enum
    184 // Study_FormFactor.
    185 Study_FormFactor GetCurrentFormFactor() {
    186   switch (ui::GetDeviceFormFactor()) {
    187     case ui::DEVICE_FORM_FACTOR_PHONE:
    188       return Study_FormFactor_PHONE;
    189     case ui::DEVICE_FORM_FACTOR_TABLET:
    190       return Study_FormFactor_TABLET;
    191     case ui::DEVICE_FORM_FACTOR_DESKTOP:
    192       return Study_FormFactor_DESKTOP;
    193   }
    194   NOTREACHED();
    195   return Study_FormFactor_DESKTOP;
    196 }
    197 
    198 // Gets the hardware class and returns it as a string. This returns an empty
    199 // string if the client is not ChromeOS.
    200 std::string GetHardwareClass() {
    201 #if defined(OS_CHROMEOS)
    202   return base::SysInfo::GetLsbReleaseBoard();
    203 #endif  // OS_CHROMEOS
    204   return std::string();
    205 }
    206 
    207 // Returns the date that should be used by the VariationsSeedProcessor to do
    208 // expiry and start date checks.
    209 base::Time GetReferenceDateForExpiryChecks(PrefService* local_state) {
    210   const int64 date_value = local_state->GetInt64(prefs::kVariationsSeedDate);
    211   const base::Time seed_date = base::Time::FromInternalValue(date_value);
    212   const base::Time build_time = base::GetBuildTime();
    213   // Use the build time for date checks if either the seed date is invalid or
    214   // the build time is newer than the seed date.
    215   base::Time reference_date = seed_date;
    216   if (seed_date.is_null() || seed_date < build_time)
    217     reference_date = build_time;
    218   return reference_date;
    219 }
    220 
    221 }  // namespace
    222 
    223 VariationsService::VariationsService(
    224     PrefService* local_state,
    225     metrics::MetricsStateManager* state_manager)
    226     : local_state_(local_state),
    227       state_manager_(state_manager),
    228       policy_pref_service_(local_state),
    229       seed_store_(local_state),
    230       create_trials_from_seed_called_(false),
    231       initial_request_completed_(false),
    232       resource_request_allowed_notifier_(new ResourceRequestAllowedNotifier),
    233       weak_ptr_factory_(this) {
    234   resource_request_allowed_notifier_->Init(this);
    235 }
    236 
    237 VariationsService::VariationsService(
    238     ResourceRequestAllowedNotifier* notifier,
    239     PrefService* local_state,
    240     metrics::MetricsStateManager* state_manager)
    241     : local_state_(local_state),
    242       state_manager_(state_manager),
    243       policy_pref_service_(local_state),
    244       seed_store_(local_state),
    245       create_trials_from_seed_called_(false),
    246       initial_request_completed_(false),
    247       resource_request_allowed_notifier_(notifier),
    248       weak_ptr_factory_(this) {
    249   resource_request_allowed_notifier_->Init(this);
    250 }
    251 
    252 VariationsService::~VariationsService() {
    253 }
    254 
    255 bool VariationsService::CreateTrialsFromSeed() {
    256   create_trials_from_seed_called_ = true;
    257 
    258   VariationsSeed seed;
    259   if (!seed_store_.LoadSeed(&seed))
    260     return false;
    261 
    262   const chrome::VersionInfo current_version_info;
    263   if (!current_version_info.is_valid())
    264     return false;
    265 
    266   const base::Version current_version(current_version_info.Version());
    267   if (!current_version.IsValid())
    268     return false;
    269 
    270   VariationsSeedProcessor().CreateTrialsFromSeed(
    271       seed, g_browser_process->GetApplicationLocale(),
    272       GetReferenceDateForExpiryChecks(local_state_), current_version,
    273       GetChannelForVariations(), GetCurrentFormFactor(), GetHardwareClass());
    274 
    275   // Log the "freshness" of the seed that was just used. The freshness is the
    276   // time between the last successful seed download and now.
    277   const int64 last_fetch_time_internal =
    278       local_state_->GetInt64(prefs::kVariationsLastFetchTime);
    279   if (last_fetch_time_internal) {
    280     const base::Time now = base::Time::Now();
    281     const base::TimeDelta delta =
    282         now - base::Time::FromInternalValue(last_fetch_time_internal);
    283     // Log the value in number of minutes.
    284     UMA_HISTOGRAM_CUSTOM_COUNTS("Variations.SeedFreshness", delta.InMinutes(),
    285         1, base::TimeDelta::FromDays(30).InMinutes(), 50);
    286   }
    287 
    288   return true;
    289 }
    290 
    291 void VariationsService::StartRepeatedVariationsSeedFetch() {
    292   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    293 
    294   // Initialize the Variations server URL.
    295   variations_server_url_ = GetVariationsServerURL(policy_pref_service_);
    296 
    297   // Check that |CreateTrialsFromSeed| was called, which is necessary to
    298   // retrieve the serial number that will be sent to the server.
    299   DCHECK(create_trials_from_seed_called_);
    300 
    301   DCHECK(!request_scheduler_.get());
    302   // Note that the act of instantiating the scheduler will start the fetch, if
    303   // the scheduler deems appropriate. Using Unretained is fine here since the
    304   // lifespan of request_scheduler_ is guaranteed to be shorter than that of
    305   // this service.
    306   request_scheduler_.reset(VariationsRequestScheduler::Create(
    307       base::Bind(&VariationsService::FetchVariationsSeed,
    308           base::Unretained(this)), local_state_));
    309   request_scheduler_->Start();
    310 }
    311 
    312 // TODO(rkaplow): Handle this and the similar event in metrics_service by
    313 // observing an 'OnAppEnterForeground' event in RequestScheduler instead of
    314 // requiring the frontend code to notify each service individually. Since the
    315 // scheduler will handle it directly the VariationService shouldn't need to
    316 // know details of this anymore.
    317 void VariationsService::OnAppEnterForeground() {
    318   request_scheduler_->OnAppEnterForeground();
    319 }
    320 
    321 // static
    322 GURL VariationsService::GetVariationsServerURL(
    323     PrefService* policy_pref_service) {
    324   std::string server_url_string(CommandLine::ForCurrentProcess()->
    325       GetSwitchValueASCII(switches::kVariationsServerURL));
    326   if (server_url_string.empty())
    327     server_url_string = kDefaultVariationsServerURL;
    328   GURL server_url = GURL(server_url_string);
    329 
    330   const std::string restrict_param =
    331       GetRestrictParameterPref(policy_pref_service);
    332   if (!restrict_param.empty()) {
    333     server_url = net::AppendOrReplaceQueryParameter(server_url,
    334                                                     "restrict",
    335                                                     restrict_param);
    336   }
    337 
    338   server_url = net::AppendOrReplaceQueryParameter(server_url, "osname",
    339                                                   GetPlatformString());
    340 
    341   DCHECK(server_url.is_valid());
    342   return server_url;
    343 }
    344 
    345 #if defined(OS_WIN)
    346 void VariationsService::StartGoogleUpdateRegistrySync() {
    347   registry_syncer_.RequestRegistrySync();
    348 }
    349 #endif
    350 
    351 void VariationsService::SetCreateTrialsFromSeedCalledForTesting(bool called) {
    352   create_trials_from_seed_called_ = called;
    353 }
    354 
    355 // static
    356 std::string VariationsService::GetDefaultVariationsServerURLForTesting() {
    357   return kDefaultVariationsServerURL;
    358 }
    359 
    360 // static
    361 void VariationsService::RegisterPrefs(PrefRegistrySimple* registry) {
    362   VariationsSeedStore::RegisterPrefs(registry);
    363   registry->RegisterInt64Pref(prefs::kVariationsLastFetchTime, 0);
    364   // This preference will only be written by the policy service, which will fill
    365   // it according to a value stored in the User Policy.
    366   registry->RegisterStringPref(prefs::kVariationsRestrictParameter,
    367                                std::string());
    368 }
    369 
    370 // static
    371 void VariationsService::RegisterProfilePrefs(
    372     user_prefs::PrefRegistrySyncable* registry) {
    373   // This preference will only be written by the policy service, which will fill
    374   // it according to a value stored in the User Policy.
    375   registry->RegisterStringPref(
    376       prefs::kVariationsRestrictParameter,
    377       std::string(),
    378       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
    379 }
    380 
    381 // static
    382 scoped_ptr<VariationsService> VariationsService::Create(
    383     PrefService* local_state,
    384     metrics::MetricsStateManager* state_manager) {
    385   scoped_ptr<VariationsService> result;
    386 #if !defined(GOOGLE_CHROME_BUILD)
    387   // Unless the URL was provided, unsupported builds should return NULL to
    388   // indicate that the service should not be used.
    389   if (!CommandLine::ForCurrentProcess()->HasSwitch(
    390           switches::kVariationsServerURL)) {
    391     DVLOG(1) << "Not creating VariationsService in unofficial build without --"
    392              << switches::kVariationsServerURL << " specified.";
    393     return result.Pass();
    394   }
    395 #endif
    396   result.reset(new VariationsService(local_state, state_manager));
    397   return result.Pass();
    398 }
    399 
    400 void VariationsService::DoActualFetch() {
    401   pending_seed_request_.reset(net::URLFetcher::Create(
    402       0, variations_server_url_, net::URLFetcher::GET, this));
    403   pending_seed_request_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
    404                                       net::LOAD_DO_NOT_SAVE_COOKIES);
    405   pending_seed_request_->SetRequestContext(
    406       g_browser_process->system_request_context());
    407   pending_seed_request_->SetMaxRetriesOn5xx(kMaxRetrySeedFetch);
    408   if (!seed_store_.variations_serial_number().empty()) {
    409     pending_seed_request_->AddExtraRequestHeader(
    410         "If-Match:" + seed_store_.variations_serial_number());
    411   }
    412   pending_seed_request_->Start();
    413 
    414   const base::TimeTicks now = base::TimeTicks::Now();
    415   base::TimeDelta time_since_last_fetch;
    416   // Record a time delta of 0 (default value) if there was no previous fetch.
    417   if (!last_request_started_time_.is_null())
    418     time_since_last_fetch = now - last_request_started_time_;
    419   UMA_HISTOGRAM_CUSTOM_COUNTS("Variations.TimeSinceLastFetchAttempt",
    420                               time_since_last_fetch.InMinutes(), 0,
    421                               base::TimeDelta::FromDays(7).InMinutes(), 50);
    422   last_request_started_time_ = now;
    423 }
    424 
    425 void VariationsService::StoreSeed(const std::string& seed_data,
    426                                   const std::string& seed_signature,
    427                                   const base::Time& date_fetched) {
    428   scoped_ptr<VariationsSeed> seed(new VariationsSeed);
    429   if (!seed_store_.StoreSeedData(seed_data, seed_signature, date_fetched,
    430                                  seed.get())) {
    431     return;
    432   }
    433   RecordLastFetchTime();
    434 
    435   // Perform seed simulation only if |state_manager_| is not-NULL. The state
    436   // manager may be NULL for some unit tests.
    437   if (!state_manager_)
    438     return;
    439 
    440   base::PostTaskAndReplyWithResult(
    441       content::BrowserThread::GetBlockingPool(),
    442       FROM_HERE,
    443       base::Bind(&GetVersionForSimulation),
    444       base::Bind(&VariationsService::PerformSimulationWithVersion,
    445                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&seed)));
    446 }
    447 
    448 void VariationsService::FetchVariationsSeed() {
    449   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    450 
    451   const ResourceRequestAllowedNotifier::State state =
    452       resource_request_allowed_notifier_->GetResourceRequestsAllowedState();
    453   RecordRequestsAllowedHistogram(ResourceRequestStateToHistogramValue(state));
    454   if (state != ResourceRequestAllowedNotifier::ALLOWED) {
    455     DVLOG(1) << "Resource requests were not allowed. Waiting for notification.";
    456     return;
    457   }
    458 
    459   DoActualFetch();
    460 }
    461 
    462 void VariationsService::OnURLFetchComplete(const net::URLFetcher* source) {
    463   DCHECK_EQ(pending_seed_request_.get(), source);
    464 
    465   const bool is_first_request = !initial_request_completed_;
    466   initial_request_completed_ = true;
    467 
    468   // The fetcher will be deleted when the request is handled.
    469   scoped_ptr<const net::URLFetcher> request(pending_seed_request_.release());
    470   const net::URLRequestStatus& request_status = request->GetStatus();
    471   if (request_status.status() != net::URLRequestStatus::SUCCESS) {
    472     UMA_HISTOGRAM_SPARSE_SLOWLY("Variations.FailedRequestErrorCode",
    473                                 -request_status.error());
    474     DVLOG(1) << "Variations server request failed with error: "
    475              << request_status.error() << ": "
    476              << net::ErrorToString(request_status.error());
    477     // It's common for the very first fetch attempt to fail (e.g. the network
    478     // may not yet be available). In such a case, try again soon, rather than
    479     // waiting the full time interval.
    480     if (is_first_request)
    481       request_scheduler_->ScheduleFetchShortly();
    482     return;
    483   }
    484 
    485   // Log the response code.
    486   const int response_code = request->GetResponseCode();
    487   UMA_HISTOGRAM_SPARSE_SLOWLY("Variations.SeedFetchResponseCode",
    488                               response_code);
    489 
    490   const base::TimeDelta latency =
    491       base::TimeTicks::Now() - last_request_started_time_;
    492 
    493   base::Time response_date;
    494   if (response_code == net::HTTP_OK ||
    495       response_code == net::HTTP_NOT_MODIFIED) {
    496     bool success = request->GetResponseHeaders()->GetDateValue(&response_date);
    497     DCHECK(success || response_date.is_null());
    498 
    499     if (!response_date.is_null()) {
    500       g_browser_process->network_time_tracker()->UpdateNetworkTime(
    501           response_date,
    502           base::TimeDelta::FromMilliseconds(kServerTimeResolutionMs),
    503           latency,
    504           base::TimeTicks::Now());
    505     }
    506   }
    507 
    508   if (response_code != net::HTTP_OK) {
    509     DVLOG(1) << "Variations server request returned non-HTTP_OK response code: "
    510              << response_code;
    511     if (response_code == net::HTTP_NOT_MODIFIED) {
    512       RecordLastFetchTime();
    513       // Update the seed date value in local state (used for expiry check on
    514       // next start up), since 304 is a successful response.
    515       seed_store_.UpdateSeedDateAndLogDayChange(response_date);
    516     }
    517     return;
    518   }
    519 
    520   std::string seed_data;
    521   bool success = request->GetResponseAsString(&seed_data);
    522   DCHECK(success);
    523 
    524   std::string seed_signature;
    525   request->GetResponseHeaders()->EnumerateHeader(NULL,
    526                                                  "X-Seed-Signature",
    527                                                  &seed_signature);
    528   StoreSeed(seed_data, seed_signature, response_date);
    529 }
    530 
    531 void VariationsService::OnResourceRequestsAllowed() {
    532   // Note that this only attempts to fetch the seed at most once per period
    533   // (kSeedFetchPeriodHours). This works because
    534   // |resource_request_allowed_notifier_| only calls this method if an
    535   // attempt was made earlier that fails (which implies that the period had
    536   // elapsed). After a successful attempt is made, the notifier will know not
    537   // to call this method again until another failed attempt occurs.
    538   RecordRequestsAllowedHistogram(RESOURCE_REQUESTS_ALLOWED_NOTIFIED);
    539   DVLOG(1) << "Retrying fetch.";
    540   DoActualFetch();
    541 
    542   // This service must have created a scheduler in order for this to be called.
    543   DCHECK(request_scheduler_.get());
    544   request_scheduler_->Reset();
    545 }
    546 
    547 void VariationsService::PerformSimulationWithVersion(
    548     scoped_ptr<VariationsSeed> seed,
    549     const base::Version& version) {
    550   if (version.IsValid())
    551     return;
    552 
    553   const base::ElapsedTimer timer;
    554 
    555   scoped_ptr<const base::FieldTrial::EntropyProvider> entropy_provider =
    556       state_manager_->CreateEntropyProvider();
    557   VariationsSeedSimulator seed_simulator(*entropy_provider);
    558 
    559   VariationsSeedSimulator::Result result = seed_simulator.SimulateSeedStudies(
    560       *seed, g_browser_process->GetApplicationLocale(),
    561       GetReferenceDateForExpiryChecks(local_state_), version,
    562       GetChannelForVariations(), GetCurrentFormFactor(), GetHardwareClass());
    563 
    564   UMA_HISTOGRAM_COUNTS_100("Variations.SimulateSeed.NormalChanges",
    565                            result.normal_group_change_count);
    566   UMA_HISTOGRAM_COUNTS_100("Variations.SimulateSeed.KillBestEffortChanges",
    567                            result.kill_best_effort_group_change_count);
    568   UMA_HISTOGRAM_COUNTS_100("Variations.SimulateSeed.KillCriticalChanges",
    569                            result.kill_critical_group_change_count);
    570 
    571   UMA_HISTOGRAM_TIMES("Variations.SimulateSeed.Duration", timer.Elapsed());
    572 }
    573 
    574 void VariationsService::RecordLastFetchTime() {
    575   // local_state_ is NULL in tests, so check it first.
    576   if (local_state_) {
    577     local_state_->SetInt64(prefs::kVariationsLastFetchTime,
    578                            base::Time::Now().ToInternalValue());
    579   }
    580 }
    581 
    582 }  // namespace chrome_variations
    583