Home | History | Annotate | Download | only in metrics 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "components/metrics/metrics_state_manager.h"
      6 
      7 #include "base/command_line.h"
      8 #include "base/guid.h"
      9 #include "base/metrics/histogram.h"
     10 #include "base/metrics/sparse_histogram.h"
     11 #include "base/prefs/pref_registry_simple.h"
     12 #include "base/prefs/pref_service.h"
     13 #include "base/rand_util.h"
     14 #include "base/strings/string_number_conversions.h"
     15 #include "base/threading/thread_restrictions.h"
     16 #include "base/time/time.h"
     17 #include "components/metrics/cloned_install_detector.h"
     18 #include "components/metrics/machine_id_provider.h"
     19 #include "components/metrics/metrics_pref_names.h"
     20 #include "components/metrics/metrics_switches.h"
     21 #include "components/variations/caching_permuted_entropy_provider.h"
     22 
     23 namespace metrics {
     24 
     25 namespace {
     26 
     27 // The argument used to generate a non-identifying entropy source. We want no
     28 // more than 13 bits of entropy, so use this max to return a number in the range
     29 // [0, 7999] as the entropy source (12.97 bits of entropy).
     30 const int kMaxLowEntropySize = 8000;
     31 
     32 // Default prefs value for prefs::kMetricsLowEntropySource to indicate that
     33 // the value has not yet been set.
     34 const int kLowEntropySourceNotSet = -1;
     35 
     36 // Generates a new non-identifying entropy source used to seed persistent
     37 // activities.
     38 int GenerateLowEntropySource() {
     39   return base::RandInt(0, kMaxLowEntropySize - 1);
     40 }
     41 
     42 }  // namespace
     43 
     44 // static
     45 bool MetricsStateManager::instance_exists_ = false;
     46 
     47 MetricsStateManager::MetricsStateManager(
     48     PrefService* local_state,
     49     const base::Callback<bool(void)>& is_reporting_enabled_callback,
     50     const StoreClientInfoCallback& store_client_info,
     51     const LoadClientInfoCallback& retrieve_client_info)
     52     : local_state_(local_state),
     53       is_reporting_enabled_callback_(is_reporting_enabled_callback),
     54       store_client_info_(store_client_info),
     55       load_client_info_(retrieve_client_info),
     56       low_entropy_source_(kLowEntropySourceNotSet),
     57       entropy_source_returned_(ENTROPY_SOURCE_NONE) {
     58   ResetMetricsIDsIfNecessary();
     59   if (IsMetricsReportingEnabled())
     60     ForceClientIdCreation();
     61 
     62   DCHECK(!instance_exists_);
     63   instance_exists_ = true;
     64 }
     65 
     66 MetricsStateManager::~MetricsStateManager() {
     67   DCHECK(instance_exists_);
     68   instance_exists_ = false;
     69 }
     70 
     71 bool MetricsStateManager::IsMetricsReportingEnabled() {
     72   return is_reporting_enabled_callback_.Run();
     73 }
     74 
     75 void MetricsStateManager::ForceClientIdCreation() {
     76   if (!client_id_.empty())
     77     return;
     78 
     79   client_id_ = local_state_->GetString(prefs::kMetricsClientID);
     80   if (!client_id_.empty()) {
     81     // It is technically sufficient to only save a backup of the client id when
     82     // it is initially generated below, but since the backup was only introduced
     83     // in M38, seed it explicitly from here for some time.
     84     BackUpCurrentClientInfo();
     85     return;
     86   }
     87 
     88   const scoped_ptr<ClientInfo> client_info_backup =
     89       LoadClientInfoAndMaybeMigrate();
     90   if (client_info_backup) {
     91     client_id_ = client_info_backup->client_id;
     92 
     93     const base::Time now = base::Time::Now();
     94 
     95     // Save the recovered client id and also try to reinstantiate the backup
     96     // values for the dates corresponding with that client id in order to avoid
     97     // weird scenarios where we could report an old client id with a recent
     98     // install date.
     99     local_state_->SetString(prefs::kMetricsClientID, client_id_);
    100     local_state_->SetInt64(prefs::kInstallDate,
    101                            client_info_backup->installation_date != 0
    102                                ? client_info_backup->installation_date
    103                                : now.ToTimeT());
    104     local_state_->SetInt64(prefs::kMetricsReportingEnabledTimestamp,
    105                            client_info_backup->reporting_enabled_date != 0
    106                                ? client_info_backup->reporting_enabled_date
    107                                : now.ToTimeT());
    108 
    109     base::TimeDelta recovered_installation_age;
    110     if (client_info_backup->installation_date != 0) {
    111       recovered_installation_age =
    112           now - base::Time::FromTimeT(client_info_backup->installation_date);
    113     }
    114     UMA_HISTOGRAM_COUNTS_10000("UMA.ClientIdBackupRecoveredWithAge",
    115                                recovered_installation_age.InHours());
    116 
    117     // Flush the backup back to persistent storage in case we re-generated
    118     // missing data above.
    119     BackUpCurrentClientInfo();
    120     return;
    121   }
    122 
    123   // Failing attempts at getting an existing client ID, generate a new one.
    124   client_id_ = base::GenerateGUID();
    125   local_state_->SetString(prefs::kMetricsClientID, client_id_);
    126 
    127   if (local_state_->GetString(prefs::kMetricsOldClientID).empty()) {
    128     // Record the timestamp of when the user opted in to UMA.
    129     local_state_->SetInt64(prefs::kMetricsReportingEnabledTimestamp,
    130                            base::Time::Now().ToTimeT());
    131   } else {
    132     UMA_HISTOGRAM_BOOLEAN("UMA.ClientIdMigrated", true);
    133   }
    134   local_state_->ClearPref(prefs::kMetricsOldClientID);
    135 
    136   BackUpCurrentClientInfo();
    137 }
    138 
    139 void MetricsStateManager::CheckForClonedInstall(
    140     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
    141   DCHECK(!cloned_install_detector_);
    142 
    143   MachineIdProvider* provider = MachineIdProvider::CreateInstance();
    144   if (!provider)
    145     return;
    146 
    147   cloned_install_detector_.reset(new ClonedInstallDetector(provider));
    148   cloned_install_detector_->CheckForClonedInstall(local_state_, task_runner);
    149 }
    150 
    151 scoped_ptr<const base::FieldTrial::EntropyProvider>
    152 MetricsStateManager::CreateEntropyProvider() {
    153   // For metrics reporting-enabled users, we combine the client ID and low
    154   // entropy source to get the final entropy source. Otherwise, only use the low
    155   // entropy source.
    156   // This has two useful properties:
    157   //  1) It makes the entropy source less identifiable for parties that do not
    158   //     know the low entropy source.
    159   //  2) It makes the final entropy source resettable.
    160   const int low_entropy_source_value = GetLowEntropySource();
    161   UMA_HISTOGRAM_SPARSE_SLOWLY("UMA.LowEntropySourceValue",
    162                               low_entropy_source_value);
    163   if (IsMetricsReportingEnabled()) {
    164     if (entropy_source_returned_ == ENTROPY_SOURCE_NONE)
    165       entropy_source_returned_ = ENTROPY_SOURCE_HIGH;
    166     const std::string high_entropy_source =
    167         client_id_ + base::IntToString(low_entropy_source_value);
    168     return scoped_ptr<const base::FieldTrial::EntropyProvider>(
    169         new SHA1EntropyProvider(high_entropy_source));
    170   }
    171 
    172   if (entropy_source_returned_ == ENTROPY_SOURCE_NONE)
    173     entropy_source_returned_ = ENTROPY_SOURCE_LOW;
    174 
    175 #if defined(OS_ANDROID) || defined(OS_IOS)
    176   return scoped_ptr<const base::FieldTrial::EntropyProvider>(
    177       new CachingPermutedEntropyProvider(local_state_,
    178                                          low_entropy_source_value,
    179                                          kMaxLowEntropySize));
    180 #else
    181   return scoped_ptr<const base::FieldTrial::EntropyProvider>(
    182       new PermutedEntropyProvider(low_entropy_source_value,
    183                                   kMaxLowEntropySize));
    184 #endif
    185 }
    186 
    187 // static
    188 scoped_ptr<MetricsStateManager> MetricsStateManager::Create(
    189     PrefService* local_state,
    190     const base::Callback<bool(void)>& is_reporting_enabled_callback,
    191     const StoreClientInfoCallback& store_client_info,
    192     const LoadClientInfoCallback& retrieve_client_info) {
    193   scoped_ptr<MetricsStateManager> result;
    194   // Note: |instance_exists_| is updated in the constructor and destructor.
    195   if (!instance_exists_) {
    196     result.reset(new MetricsStateManager(local_state,
    197                                          is_reporting_enabled_callback,
    198                                          store_client_info,
    199                                          retrieve_client_info));
    200   }
    201   return result.Pass();
    202 }
    203 
    204 // static
    205 void MetricsStateManager::RegisterPrefs(PrefRegistrySimple* registry) {
    206   registry->RegisterBooleanPref(prefs::kMetricsResetIds, false);
    207   registry->RegisterStringPref(prefs::kMetricsClientID, std::string());
    208   registry->RegisterInt64Pref(prefs::kMetricsReportingEnabledTimestamp, 0);
    209   registry->RegisterIntegerPref(prefs::kMetricsLowEntropySource,
    210                                 kLowEntropySourceNotSet);
    211 
    212   ClonedInstallDetector::RegisterPrefs(registry);
    213   CachingPermutedEntropyProvider::RegisterPrefs(registry);
    214 
    215   // TODO(asvitkine): Remove these once a couple of releases have passed.
    216   // http://crbug.com/357704
    217   registry->RegisterStringPref(prefs::kMetricsOldClientID, std::string());
    218   registry->RegisterIntegerPref(prefs::kMetricsOldLowEntropySource, 0);
    219 }
    220 
    221 void MetricsStateManager::BackUpCurrentClientInfo() {
    222   // TODO(gayane): Eliminate use of ScopedAllowIO. crbug.com/413783
    223   base::ThreadRestrictions::ScopedAllowIO allow_io;
    224 
    225   ClientInfo client_info;
    226   client_info.client_id = client_id_;
    227   client_info.installation_date = local_state_->GetInt64(prefs::kInstallDate);
    228   client_info.reporting_enabled_date =
    229       local_state_->GetInt64(prefs::kMetricsReportingEnabledTimestamp);
    230   store_client_info_.Run(client_info);
    231 }
    232 
    233 scoped_ptr<ClientInfo> MetricsStateManager::LoadClientInfoAndMaybeMigrate() {
    234   scoped_ptr<metrics::ClientInfo> client_info = load_client_info_.Run();
    235 
    236   // Prior to 2014-07, the client ID was stripped of its dashes before being
    237   // saved. Migrate back to a proper GUID if this is the case. This migration
    238   // code can be removed in M41+.
    239   const size_t kGUIDLengthWithoutDashes = 32U;
    240   if (client_info &&
    241       client_info->client_id.length() == kGUIDLengthWithoutDashes) {
    242     DCHECK(client_info->client_id.find('-') == std::string::npos);
    243 
    244     std::string client_id_with_dashes;
    245     client_id_with_dashes.reserve(kGUIDLengthWithoutDashes + 4U);
    246     std::string::const_iterator client_id_it = client_info->client_id.begin();
    247     for (size_t i = 0; i < kGUIDLengthWithoutDashes + 4U; ++i) {
    248       if (i == 8U || i == 13U || i == 18U || i == 23U) {
    249         client_id_with_dashes.push_back('-');
    250       } else {
    251         client_id_with_dashes.push_back(*client_id_it);
    252         ++client_id_it;
    253       }
    254     }
    255     DCHECK(client_id_it == client_info->client_id.end());
    256     client_info->client_id.assign(client_id_with_dashes);
    257   }
    258 
    259   // The GUID retrieved (and possibly fixed above) should be valid unless
    260   // retrieval failed.
    261   DCHECK(!client_info || base::IsValidGUID(client_info->client_id));
    262 
    263   return client_info.Pass();
    264 }
    265 
    266 int MetricsStateManager::GetLowEntropySource() {
    267   // Note that the default value for the low entropy source and the default pref
    268   // value are both kLowEntropySourceNotSet, which is used to identify if the
    269   // value has been set or not.
    270   if (low_entropy_source_ != kLowEntropySourceNotSet)
    271     return low_entropy_source_;
    272 
    273   const CommandLine* command_line(CommandLine::ForCurrentProcess());
    274   // Only try to load the value from prefs if the user did not request a
    275   // reset.
    276   // Otherwise, skip to generating a new value.
    277   if (!command_line->HasSwitch(switches::kResetVariationState)) {
    278     int value = local_state_->GetInteger(prefs::kMetricsLowEntropySource);
    279     // If the value is outside the [0, kMaxLowEntropySize) range, re-generate
    280     // it below.
    281     if (value >= 0 && value < kMaxLowEntropySize) {
    282       low_entropy_source_ = value;
    283       UMA_HISTOGRAM_BOOLEAN("UMA.GeneratedLowEntropySource", false);
    284       return low_entropy_source_;
    285     }
    286   }
    287 
    288   UMA_HISTOGRAM_BOOLEAN("UMA.GeneratedLowEntropySource", true);
    289   low_entropy_source_ = GenerateLowEntropySource();
    290   local_state_->SetInteger(prefs::kMetricsLowEntropySource,
    291                            low_entropy_source_);
    292   local_state_->ClearPref(prefs::kMetricsOldLowEntropySource);
    293   CachingPermutedEntropyProvider::ClearCache(local_state_);
    294 
    295   return low_entropy_source_;
    296 }
    297 
    298 void MetricsStateManager::ResetMetricsIDsIfNecessary() {
    299   if (!local_state_->GetBoolean(prefs::kMetricsResetIds))
    300     return;
    301 
    302   UMA_HISTOGRAM_BOOLEAN("UMA.MetricsIDsReset", true);
    303 
    304   DCHECK(client_id_.empty());
    305   DCHECK_EQ(kLowEntropySourceNotSet, low_entropy_source_);
    306 
    307   local_state_->ClearPref(prefs::kMetricsClientID);
    308   local_state_->ClearPref(prefs::kMetricsLowEntropySource);
    309   local_state_->ClearPref(prefs::kMetricsResetIds);
    310 
    311   // Also clear the backed up client info.
    312   store_client_info_.Run(ClientInfo());
    313 }
    314 
    315 }  // namespace metrics
    316