Use a different algorithm with the low entropy source for field trials.

chrome/browser/metrics/metrics_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.
 
 //------------------------------------------------------------------------------
 // Description of the life cycle of a instance of MetricsService.
 //
 //  OVERVIEW
 //
 // A MetricsService instance is typically created at application startup.  It
@@ skipping 167 matching lines @@
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_otr_state.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_result_codes.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/metrics/entropy_provider.h"
 #include "chrome/common/metrics/metrics_log_manager.h"
 #include "chrome/common/net/test_server_locations.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/histogram_fetcher.h"
 #include "content/public/browser/load_notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/render_process_host.h"
@@ skipping 74 matching lines @@
 }
 
 // The argument used to generate a non-identifying entropy source. We want no
 // more than 13 bits of entropy, so use this max to return a number between 1
 // and 2^13 = 8192 as the entropy source.
 const uint32 kMaxEntropySize = (1 << 13);
 
 // Generates a new non-identifying entropy source used to seed persistent
 // activities.
 int GenerateLowEntropySource() {
-  return base::RandInt(1, kMaxEntropySize);
+  return base::RandInt(0, kMaxEntropySize - 1);
 }
 
 // Converts an exit code into something that can be inserted into our
 // histograms (which expect non-negative numbers less than MAX_INT).
 int MapCrashExitCodeForHistogram(int exit_code) {
 #if defined(OS_WIN)
   // Since |abs(STATUS_GUARD_PAGE_VIOLATION) == MAX_INT| it causes problems in
   // histograms.cc. Solve this by remapping it to a smaller value, which
   // hopefully doesn't conflict with other codes.
   if (exit_code == STATUS_GUARD_PAGE_VIOLATION)
@@ skipping 44 matching lines @@
     STATUS_STACK_OVERFLOW,
   };
 
   for (size_t i = 0; i < arraysize(kExceptionCodes); ++i)
     codes.push_back(MapCrashExitCodeForHistogram(kExceptionCodes[i]));
 #endif
 
   return codes;
 }
 
-}
+}  // namespace
 
 // static
 MetricsService::ShutdownCleanliness MetricsService::clean_shutdown_status_ =
     MetricsService::CLEANLY_SHUTDOWN;
 
 // This is used to quickly log stats from child process related notifications in
 // MetricsService::child_stats_buffer_.  The buffer's contents are transferred
 // out when Local State is periodically saved.  The information is then
 // reported to the UMA server on next launch.
 struct MetricsService::ChildProcessStats {
@@ skipping 174 matching lines @@
 void MetricsService::Stop() {
   HandleIdleSinceLastTransmission(false);
   SetReporting(false);
   SetRecording(false);
 }
 
 std::string MetricsService::GetClientId() {
   return client_id_;
 }
 
-std::string MetricsService::GetEntropySource(bool reporting_will_be_enabled) {
+base::FieldTrial::EntropyProvider* MetricsService::GetEntropyProvider(
+    bool reporting_will_be_enabled) {
+  const int low_entropy_source = GetLowEntropySource();
+
   // 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.
-  std::string low_entropy_source = base::IntToString(GetLowEntropySource());
   if (reporting_will_be_enabled) {
     entropy_source_returned_ = LAST_ENTROPY_HIGH;
-    return client_id_ + low_entropy_source;
+    const std::string high_entropy_source =
+        client_id_ + base::IntToString(low_entropy_source);
+    return new SHA1EntropyProvider(high_entropy_source);

[Ilya Sherman, 2012/08/17 07:34:28]

I'm not a fan of functions that return heap-allocated memory.  This places the
burden on the caller to remember to free the memory, or else we leak it.  Can
you return a scoped_ptr instead, e.g. using the Pass() method to transfer
ownership?

[Alexei Svitkine (slow), 2012/08/17 14:08:59]

Done.

   }
+
   entropy_source_returned_ = LAST_ENTROPY_LOW;
-  return low_entropy_source;
+  return new PermutedEntropyProvider(GetLowEntropySource(), kMaxEntropySize);
 }
 
 void MetricsService::ForceClientIdCreation() {
   if (!client_id_.empty())
     return;
   PrefService* pref = g_browser_process->local_state();
   client_id_ = pref->GetString(prefs::kMetricsClientID);
   if (!client_id_.empty())
     return;
 
@@ skipping 1342 matching lines @@
   if (local_state) {
     const PrefService::Preference* uma_pref =
         local_state->FindPreference(prefs::kMetricsReportingEnabled);
     if (uma_pref) {
       bool success = uma_pref->GetValue()->GetAsBoolean(&result);
       DCHECK(success);
     }
   }
   return result;
 }