Retrieve client_id from GoogleUpdateSettings when its missing from Local State.

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 "base/command_line.h"
 #include "base/guid.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
@@ skipping 27 matching lines @@
   return base::RandInt(0, kMaxLowEntropySize - 1);
 }
 
 }  // namespace
 
 // static
 bool MetricsStateManager::instance_exists_ = false;
 
 MetricsStateManager::MetricsStateManager(
     PrefService* local_state,
-    const base::Callback<bool(void)>& is_reporting_enabled_callback)
+    const base::Callback<bool(void)>& is_reporting_enabled_callback,
+    const SaveClientInfoCallback& save_client_info,
+    const RetrieveClientInfoCallback& retrieve_client_info)
     : local_state_(local_state),
       is_reporting_enabled_callback_(is_reporting_enabled_callback),
+      save_client_info_(save_client_info),
+      retrieve_client_info_(retrieve_client_info),
       low_entropy_source_(kLowEntropySourceNotSet),
       entropy_source_returned_(ENTROPY_SOURCE_NONE) {
   ResetMetricsIDsIfNecessary();
   if (IsMetricsReportingEnabled())
     ForceClientIdCreation();
 
   DCHECK(!instance_exists_);
   instance_exists_ = true;
 }
 
 MetricsStateManager::~MetricsStateManager() {
   DCHECK(instance_exists_);
   instance_exists_ = false;
 }
 
 bool MetricsStateManager::IsMetricsReportingEnabled() {
   return is_reporting_enabled_callback_.Run();
 }
 
 void MetricsStateManager::ForceClientIdCreation() {
   if (!client_id_.empty())
     return;
 
   client_id_ = local_state_->GetString(prefs::kMetricsClientID);
-  if (!client_id_.empty())
+  if (!client_id_.empty()) {
+    // It is technically sufficient to only save a backup of the client id when
+    // it is initially generated below, but since the backup was only introduced
+    // in M38, seed it explicitly from here for some time.
+    const int64 installation_date = local_state_->GetInt64(prefs::kInstallDate);
+    save_client_info_.Run(client_id_, installation_date);
     return;
+  }
 
+  std::string client_id_backup;
+  int64 installation_date_backup = 0;
+  if (retrieve_client_info_.Run(&client_id_backup, &installation_date_backup) &&
+      !client_id_backup.empty()) {
+    client_id_ = client_id_backup;
+
+    const base::Time now(base::Time::Now());
+    if (installation_date_backup == 0)
+      installation_date_backup = now.ToTimeT();
+    // Save the recovered client id and set the install date to match the
+    // recovered client id in order to avoid weird scenarios where we could
+    // report an old client id with a recent install date.
+    local_state_->SetString(prefs::kMetricsClientID, client_id_);
+    local_state_->SetInt64(prefs::kInstallDate, installation_date_backup);
+    local_state_->SetInt64(prefs::kMetricsReportingEnabledTimestamp,
+                           now.ToTimeT());
+
+    base::TimeDelta recovered_installation_age;
+    if (installation_date_backup != 0) {

[Ilya Sherman, 2014/07/08 01:10:22]

Given lines 95-96, I don't think this check does anything.

+      recovered_installation_age =
+          now - base::Time::FromTimeT(installation_date_backup);
+    }
+    UMA_HISTOGRAM_CUSTOM_TIMES("UMA.ClientIdBackupRecoveredWithAge",
+                               recovered_installation_age,
+                               base::TimeDelta::FromHours(0),
+                               base::TimeDelta::FromDays(365),
+                               100);
+    return;
+  }
+
+  // Failing attempts at getting an existing client ID, generate a new one.
   client_id_ = base::GenerateGUID();
   local_state_->SetString(prefs::kMetricsClientID, client_id_);
 
   if (local_state_->GetString(prefs::kMetricsOldClientID).empty()) {
     // Record the timestamp of when the user opted in to UMA.
     local_state_->SetInt64(prefs::kMetricsReportingEnabledTimestamp,
                            base::Time::Now().ToTimeT());
   } else {
     UMA_HISTOGRAM_BOOLEAN("UMA.ClientIdMigrated", true);
   }
   local_state_->ClearPref(prefs::kMetricsOldClientID);
+
+  const int64 installation_date = local_state_->GetInt64(prefs::kInstallDate);
+  save_client_info_.Run(client_id_, installation_date);
 }
 
 void MetricsStateManager::CheckForClonedInstall(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   DCHECK(!cloned_install_detector_);
 
   MachineIdProvider* provider = MachineIdProvider::CreateInstance();
   if (!provider)
     return;
 
@@ skipping 35 matching lines @@
 #else
   return scoped_ptr<const base::FieldTrial::EntropyProvider>(
       new PermutedEntropyProvider(low_entropy_source_value,
                                   kMaxLowEntropySize));
 #endif
 }
 
 // static
 scoped_ptr<MetricsStateManager> MetricsStateManager::Create(
     PrefService* local_state,
-    const base::Callback<bool(void)>& is_reporting_enabled_callback) {
+    const base::Callback<bool(void)>& is_reporting_enabled_callback,
+    const SaveClientInfoCallback& save_client_info,
+    const RetrieveClientInfoCallback& retrieve_client_info) {
   scoped_ptr<MetricsStateManager> result;
   // Note: |instance_exists_| is updated in the constructor and destructor.
   if (!instance_exists_) {
-    result.reset(
-        new MetricsStateManager(local_state, is_reporting_enabled_callback));
+    result.reset(new MetricsStateManager(local_state,
+                                         is_reporting_enabled_callback,
+                                         save_client_info,
+                                         retrieve_client_info));
   }
   return result.Pass();
 }
 
 // static
 void MetricsStateManager::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterBooleanPref(prefs::kMetricsResetIds, false);
   registry->RegisterStringPref(prefs::kMetricsClientID, std::string());
   registry->RegisterInt64Pref(prefs::kMetricsReportingEnabledTimestamp, 0);
   registry->RegisterIntegerPref(prefs::kMetricsLowEntropySource,
@@ skipping 48 matching lines @@
 
   DCHECK(client_id_.empty());
   DCHECK_EQ(kLowEntropySourceNotSet, low_entropy_source_);
 
   local_state_->ClearPref(prefs::kMetricsClientID);
   local_state_->ClearPref(prefs::kMetricsLowEntropySource);
   local_state_->ClearPref(prefs::kMetricsResetIds);
 }
 
 }  // namespace metrics