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 503 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),
+    : variations_state_initialized_(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 16 matching lines @@
 
 void MetricsService::InitializeMetricsRecordingState(
     ReportingState reporting_state) {
   InitializeMetricsState(reporting_state);
 
   base::Closure callback = base::Bind(&MetricsService::StartScheduledUpload,
                                       self_ptr_factory_.GetWeakPtr());
   scheduler_.reset(new MetricsReportingScheduler(callback));
 }
 
+void MetricsService::InitializeVariationsState(bool recording_enabled) {
+  if (!variations_state_initialized_) {
+    variations_state_initialized_ = true;
+
+    if (g_browser_process->local_state()->GetBoolean(
+        prefs::kMetricsCloneDetected))
+      ResetVariationsState();
+  }
+
+  GetLowEntropySource();
+
+  if (recording_enabled)

[Alexei Svitkine (slow), 2014/03/28 15:00:17]

Hmm, this requires the caller to know this, which we don't from
GetLowEntropySource()...

Let's go with ResetMetricsIDsIfNecessary() instead and call it from both places
and a have a bool to guard if we did the check already.

[jwd, 2014/03/28 16:23:50]

Done.

+    ForceClientIdCreation();
+}
+
 void MetricsService::Start() {
   HandleIdleSinceLastTransmission(false);
   EnableRecording();
   EnableReporting();
 }
 
 void MetricsService::StartRecordingForTests() {
   test_mode_active_ = true;
   EnableRecording();
   DisableReporting();
@@ skipping 55 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;
+
   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 539 matching lines @@
   }
 }
 
 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_;
 
+  ResetVariationsState();

[Alexei Svitkine (slow), 2014/03/28 15:00:17]

Why is this called from here? Did you mean Initialize instead?

[jwd, 2014/03/28 16:23:50]

Done.

+
   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));
 
   PrefService* local_state = g_browser_process->local_state();
   cloned_install_detector_->CheckForClonedInstall(local_state);
 }
 
+void MetricsService::ResetVariationsState() {
+  PrefService* local_state = g_browser_process->local_state();
+  DCHECK(local_state->GetBoolean(prefs::kMetricsCloneDetected));
+  DCHECK(client_id_.empty());
+  DCHECK(low_entropy_source_ == kLowEntropySourceNotSet);
+
+  DVLOG(2) << "\n\nresetting variatinos state\n\n";
+
+  local_state->ClearPref(prefs::kMetricsClientID);
+  local_state->ClearPref(prefs::kMetricsLowEntropySource);
+  local_state->SetBoolean(prefs::kMetricsCloneDetected, false);
+}
+
 void MetricsService::GetCurrentSyntheticFieldTrials(
     std::vector<chrome_variations::ActiveGroupId>* synthetic_trials) {
   DCHECK(synthetic_trials);
   synthetic_trials->clear();
   const MetricsLog* current_log =
       static_cast<const MetricsLog*>(log_manager_.current_log());
   for (size_t i = 0; i < synthetic_trial_groups_.size(); ++i) {
     if (synthetic_trial_groups_[i].start_time <= current_log->creation_time())
       synthetic_trials->push_back(synthetic_trial_groups_[i].id);
   }
@@ skipping 209 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
 }