Resetting metrics ids on clump detection.

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 is
@@ skipping 421 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(MetricsMemoryDetails);
 };
 
 // static
 void MetricsService::RegisterPrefs(PrefRegistrySimple* registry) {
   DCHECK(IsSingleThreaded());
   registry->RegisterStringPref(prefs::kMetricsClientID, std::string());
   registry->RegisterIntegerPref(prefs::kMetricsLowEntropySource,
                                 kLowEntropySourceNotSet);
   registry->RegisterInt64Pref(prefs::kMetricsClientIDTimestamp, 0);
+  registry->RegisterBooleanPref(prefs::kMetricsResetIds, false);
   registry->RegisterInt64Pref(prefs::kStabilityLaunchTimeSec, 0);
   registry->RegisterInt64Pref(prefs::kStabilityLastTimestampSec, 0);
   registry->RegisterStringPref(prefs::kStabilityStatsVersion, std::string());
   registry->RegisterInt64Pref(prefs::kStabilityStatsBuildTime, 0);
   registry->RegisterBooleanPref(prefs::kStabilityExitedCleanly, true);
   registry->RegisterIntegerPref(prefs::kStabilityExecutionPhase,
                                 UNINITIALIZED_PHASE);
   registry->RegisterBooleanPref(prefs::kStabilitySessionEndCompleted, true);
   registry->RegisterIntegerPref(prefs::kMetricsSessionID, -1);
   registry->RegisterIntegerPref(prefs::kStabilityLaunchCount, 0);
@@ skipping 62 matching lines @@
 
   local_state->ClearPref(prefs::kMetricsInitialLogs);
   local_state->ClearPref(prefs::kMetricsOngoingLogs);
 
 #if defined(OS_ANDROID)
   DiscardOldStabilityStatsAndroid(local_state);
 #endif  // defined(OS_ANDROID)
 }
 
 MetricsService::MetricsService()
-    : recording_active_(false),
+    : metrics_ids_reset_(false),
+      recording_active_(false),
       reporting_active_(false),
       test_mode_active_(false),
       state_(INITIALIZED),
       has_initial_stability_log_(false),
       low_entropy_source_(kLowEntropySourceNotSet),
       idle_since_last_transmission_(false),
       session_id_(-1),
       next_window_id_(0),
       self_ptr_factory_(this),
       state_saver_factory_(this),
@@ skipping 91 matching lines @@
 #else
   return scoped_ptr<const base::FieldTrial::EntropyProvider>(
       new metrics::PermutedEntropyProvider(low_entropy_source_value,
                                            kMaxLowEntropySize));
 #endif
 }
 
 void MetricsService::ForceClientIdCreation() {
   if (!client_id_.empty())
     return;
+
+  ResetMetricsIDsIfNecessary();
+
   PrefService* pref = g_browser_process->local_state();
   client_id_ = pref->GetString(prefs::kMetricsClientID);
   if (!client_id_.empty())
     return;
 
   client_id_ = GenerateClientID();
   pref->SetString(prefs::kMetricsClientID, client_id_);
 
   // Might as well make a note of how long this ID has existed
   pref->SetString(prefs::kMetricsClientIDTimestamp,
@@ skipping 532 matching lines @@
   last_updated_time_ = now;
 
   const int64 incremental_time_secs = incremental_uptime->InSeconds();
   if (incremental_time_secs > 0) {
     int64 metrics_uptime = pref->GetInt64(prefs::kUninstallMetricsUptimeSec);
     metrics_uptime += incremental_time_secs;
     pref->SetInt64(prefs::kUninstallMetricsUptimeSec, metrics_uptime);
   }
 }
 
+void MetricsService::ResetMetricsIDsIfNecessary() {
+  if (metrics_ids_reset_)
+    return;
+
+  metrics_ids_reset_ = true;
+
+  PrefService* local_state = g_browser_process->local_state();
+  if (!local_state->GetBoolean(prefs::kMetricsResetIds))
+    return;
+
+  DCHECK(client_id_.empty());
+  DCHECK(low_entropy_source_ == kLowEntropySourceNotSet);

[Alexei Svitkine (slow), 2014/03/28 17:20:26]

Nit: DCHECK_EQ and put kLowEntropySourceNotSet on the left side.

[jwd, 2014/03/28 18:59:21]

Done.

+
+  local_state->ClearPref(prefs::kMetricsClientID);
+  local_state->ClearPref(prefs::kMetricsLowEntropySource);
+  local_state->ClearPref(prefs::kMetricsResetIds);
+}
+
 int MetricsService::GetLowEntropySource() {
   // Note that the default value for the low entropy source and the default pref
   // value are both kLowEntropySourceNotSet, which is used to identify if the
   // value has been set or not.
   if (low_entropy_source_ != kLowEntropySourceNotSet)
     return low_entropy_source_;
 
+  ResetMetricsIDsIfNecessary();
+
   PrefService* local_state = g_browser_process->local_state();
   const CommandLine* command_line(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);
     // Old versions of the code would generate values in the range of [1, 8192],
     // before the range was switched to [0, 8191] and then to [0, 7999]. Map
     // 8192 to 0, so that the 0th bucket remains uniform, while re-generating
     // the low entropy source for old values in the [8000, 8191] range.
@@ skipping 650 matching lines @@
       return;
     }
   }
 
   SyntheticTrialGroup trial_group = trial;
   trial_group.start_time = base::TimeTicks::Now();
   synthetic_trial_groups_.push_back(trial_group);
 }
 
 void MetricsService::CheckForClonedInstall() {
+  DVLOG(2) << "\n\nChecking for cloned installs\n\n";
   DCHECK(!cloned_install_detector_);
 
   metrics::MachineIdProvider* provider =
       metrics::MachineIdProvider::CreateInstance();
   if (!provider)
     return;
 
   cloned_install_detector_.reset(
       new metrics::ClonedInstallDetector(provider));
 
@@ skipping 223 matching lines @@
   // Android has its own settings for metrics / crash uploading.
   const PrefService* prefs = g_browser_process->local_state();
   return prefs->GetBoolean(prefs::kCrashReportingEnabled);
 #else
   return MetricsServiceHelper::IsMetricsReportingEnabled();
 #endif
 #else
   return false;
 #endif
 }