Use low entropy for studies that send experiment IDs to Google properties.

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 318 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);
+
+  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,
       LoadPermanentConsistencyCountry(current_version, latest_country),
       base::Bind(&UIStringOverrider::OverrideUIString,
                  base::Unretained(&ui_string_overrider_)),
-      feature_list);
+      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 =
         now - base::Time::FromInternalValue(last_fetch_time_internal);
     // Log the value in number of minutes.
     UMA_HISTOGRAM_CUSTOM_COUNTS("Variations.SeedFreshness", delta.InMinutes(),
@@ skipping 227 matching lines @@
     return true;
 
   base::PostTaskAndReplyWithResult(
       client_->GetBlockingPool(), FROM_HERE,
       client_->GetVersionForSimulationCallback(),
       base::Bind(&VariationsService::PerformSimulationWithVersion,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&seed)));
   return true;
 }
 
+std::unique_ptr<const base::FieldTrial::EntropyProvider>
+VariationsService::CreateLowEntropyProvider() {
+  return state_manager_->CreateLowEntropyProvider();
+}
+
 bool VariationsService::LoadSeed(VariationsSeed* seed) {
   return seed_store_.LoadSeed(seed);
 }
 
 void VariationsService::FetchVariationsSeed() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const web_resource::ResourceRequestAllowedNotifier::State state =
       resource_request_allowed_notifier_->GetResourceRequestsAllowedState();
   RecordRequestsAllowedHistogram(ResourceRequestStateToHistogramValue(state));
@@ skipping 124 matching lines @@
 void VariationsService::PerformSimulationWithVersion(
     std::unique_ptr<variations::VariationsSeed> seed,
     const base::Version& version) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!version.IsValid())
     return;
 
   const base::ElapsedTimer timer;
 
-  std::unique_ptr<const base::FieldTrial::EntropyProvider> entropy_provider =
-      state_manager_->CreateEntropyProvider();
-  variations::VariationsSeedSimulator seed_simulator(*entropy_provider);
+  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 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));
@@ skipping 131 matching lines @@
 
   if (got_stored_country && stored_country == country_override)
     return false;
 
   base::Version version(version_info::GetVersionNumber());
   StorePermanentCountry(version, country_override);
   return true;
 }
 
 }  // namespace variations