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 145 matching lines @@
 // twice.  For example, if a log file is sent, but not yet acknowledged by
 // the external server, and the user shuts down, then a copy of the log may be
 // saved for re-transmission.  These duplicates could be filtered out server
 // side, but are not expected to be a significant problem.
 //
 //
 //------------------------------------------------------------------------------
 
 #include "chrome/browser/metrics/metrics_service.h"
 
+#include "base/debug/stack_trace.h"
+
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/guid.h"
 #include "base/md5.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/metrics/statistics_recorder.h"
@@ skipping 448 matching lines @@
           low_entropy_source_value,
           kMaxLowEntropySize));
 #else
   return scoped_ptr<const base::FieldTrial::EntropyProvider>(
       new metrics::PermutedEntropyProvider(low_entropy_source_value,
                                            kMaxLowEntropySize));
 #endif
 }
 
 void MetricsService::ForceClientIdCreation() {
+  DVLOG(2) << "\n\nCreating client id\n\n";
+  base::debug::StackTrace st;
+  // DVLOG(2) << st.ToString();
   if (!client_id_.empty())
     return;
+  DVLOG(2) << "\n\nActually creating id\n\n";
   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 533 matching lines @@
 
   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);
   }
 }
 
 int MetricsService::GetLowEntropySource() {
+  DVLOG(2) << "\n\nGetting LES\n\n";
+  base::debug::StackTrace st;
+  // DVLOG(2) << st.ToString();
   // 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_;
 
   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.
@@ skipping 656 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);

[Alexei Svitkine (slow), 2014/03/26 21:34:50]

Why not ClearPref()?

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

Done.

+}
+
 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
 }