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

components/metrics/metrics_state_manager.cc

 // Copyright 2014 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/metrics/metrics_state_manager.h"
 
 #include <stddef.h>
 
 #include "base/command_line.h"
 #include "base/guid.h"
@@ skipping 25 matching lines @@
 // Default prefs value for prefs::kMetricsLowEntropySource to indicate that
 // the value has not yet been set.
 const int kLowEntropySourceNotSet = -1;
 
 // Generates a new non-identifying entropy source used to seed persistent
 // activities.
 int GenerateLowEntropySource() {
   return base::RandInt(0, kMaxLowEntropySize - 1);
 }
 
+// Records the given |low_entorpy_source_value| in a histogram.
+void LogLowEntropyValue(int low_entropy_source_value) {
+  UMA_HISTOGRAM_SPARSE_SLOWLY("UMA.LowEntropySourceValue",
+                              low_entropy_source_value);
+}
+
 }  // namespace
 
 // static
 bool MetricsStateManager::instance_exists_ = false;
 
 MetricsStateManager::MetricsStateManager(
     PrefService* local_state,
     EnabledStateProvider* enabled_state_provider,
     const StoreClientInfoCallback& store_client_info,
     const LoadClientInfoCallback& retrieve_client_info)
@@ skipping 85 matching lines @@
 
   MachineIdProvider* provider = MachineIdProvider::CreateInstance();
   if (!provider)
     return;
 
   cloned_install_detector_.reset(new ClonedInstallDetector(provider));
   cloned_install_detector_->CheckForClonedInstall(local_state_, task_runner);
 }
 
 std::unique_ptr<const base::FieldTrial::EntropyProvider>
-MetricsStateManager::CreateEntropyProvider() {
+MetricsStateManager::CreateDefaultEntropyProvider() {
   // For metrics reporting-enabled users, we combine the client ID and low
   // entropy source to get the final entropy source. Otherwise, only use the low
   // entropy source.
   // This has two useful properties:
   //  1) It makes the entropy source less identifiable for parties that do not
   //     know the low entropy source.
   //  2) It makes the final entropy source resettable.
   const int low_entropy_source_value = GetLowEntropySource();

[Alexei Svitkine (slow), 2016/05/18 15:03:30]

Nit: Move this inside the if, so that it's not done redundantly if the if is
false.

[jwd, 2016/05/18 18:31:41]

Done.

-  UMA_HISTOGRAM_SPARSE_SLOWLY("UMA.LowEntropySourceValue",
-                              low_entropy_source_value);
   if (enabled_state_provider_->IsConsentGiven()) {
     UpdateEntropySourceReturnedValue(ENTROPY_SOURCE_HIGH);
     const std::string high_entropy_source =
         client_id_ + base::IntToString(low_entropy_source_value);
     return std::unique_ptr<const base::FieldTrial::EntropyProvider>(
         new SHA1EntropyProvider(high_entropy_source));
   }
 
   UpdateEntropySourceReturnedValue(ENTROPY_SOURCE_LOW);
+  return CreateLowEntropyProvider();
+}
+
+std::unique_ptr<const base::FieldTrial::EntropyProvider>
+MetricsStateManager::CreateLowEntropyProvider() {
+  const int low_entropy_source_value = GetLowEntropySource();
+
 #if defined(OS_ANDROID) || defined(OS_IOS)
   return std::unique_ptr<const base::FieldTrial::EntropyProvider>(
       new CachingPermutedEntropyProvider(local_state_, low_entropy_source_value,
                                          kMaxLowEntropySize));
 #else
   return std::unique_ptr<const base::FieldTrial::EntropyProvider>(
       new PermutedEntropyProvider(low_entropy_source_value,
                                   kMaxLowEntropySize));
 #endif
 }
@@ skipping 10 matching lines @@
     result.reset(new MetricsStateManager(local_state, enabled_state_provider,
                                          store_client_info,
                                          retrieve_client_info));
   }
   return result;
 }
 
 // static
 void MetricsStateManager::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterBooleanPref(prefs::kMetricsResetIds, false);
-  // registry->RegisterIntegerPref(prefs::kMetricsDefaultOptIn,
-  // DEFAULT_UNKNOWN);
   registry->RegisterStringPref(prefs::kMetricsClientID, std::string());
   registry->RegisterInt64Pref(prefs::kMetricsReportingEnabledTimestamp, 0);
   registry->RegisterIntegerPref(prefs::kMetricsLowEntropySource,
                                 kLowEntropySourceNotSet);
 
   ClonedInstallDetector::RegisterPrefs(registry);
   CachingPermutedEntropyProvider::RegisterPrefs(registry);
 }
 
 void MetricsStateManager::BackUpCurrentClientInfo() {
@@ skipping 54 matching lines @@
   const base::CommandLine* command_line(base::CommandLine::ForCurrentProcess());
   // Only try to load the value from prefs if the user did not request a
   // reset.
   // Otherwise, skip to generating a new value.
   if (!command_line->HasSwitch(switches::kResetVariationState)) {
     int value = local_state_->GetInteger(prefs::kMetricsLowEntropySource);
     // If the value is outside the [0, kMaxLowEntropySize) range, re-generate
     // it below.
     if (value >= 0 && value < kMaxLowEntropySize) {
       low_entropy_source_ = value;
+      LogLowEntropyValue(low_entropy_source_);
       return;
     }
   }
 
   low_entropy_source_ = GenerateLowEntropySource();
+  LogLowEntropyValue(low_entropy_source_);
   local_state_->SetInteger(prefs::kMetricsLowEntropySource,
                            low_entropy_source_);
   CachingPermutedEntropyProvider::ClearCache(local_state_);
 }
 
 void MetricsStateManager::UpdateEntropySourceReturnedValue(
     EntropySourceType type) {
   if (entropy_source_returned_ != ENTROPY_SOURCE_NONE)
     return;
 
@@ skipping 13 matching lines @@
 
   local_state_->ClearPref(prefs::kMetricsClientID);
   local_state_->ClearPref(prefs::kMetricsLowEntropySource);
   local_state_->ClearPref(prefs::kMetricsResetIds);
 
   // Also clear the backed up client info.
   store_client_info_.Run(ClientInfo());
 }
 
 }  // namespace metrics