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.
GenerateLowEntropySource()38 int GenerateLowEntropySource() {
39 return base::RandInt(0, kMaxLowEntropySize - 1);
40 }
41
42 } // namespace
43
44 // static
45 bool MetricsStateManager::instance_exists_ = false;
46
MetricsStateManager(PrefService * local_state,const base::Callback<bool (void)> & is_reporting_enabled_callback,const StoreClientInfoCallback & store_client_info,const LoadClientInfoCallback & retrieve_client_info)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
~MetricsStateManager()66 MetricsStateManager::~MetricsStateManager() {
67 DCHECK(instance_exists_);
68 instance_exists_ = false;
69 }
70
IsMetricsReportingEnabled()71 bool MetricsStateManager::IsMetricsReportingEnabled() {
72 return is_reporting_enabled_callback_.Run();
73 }
74
ForceClientIdCreation()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
CheckForClonedInstall(scoped_refptr<base::SingleThreadTaskRunner> task_runner)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>
CreateEntropyProvider()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
Create(PrefService * local_state,const base::Callback<bool (void)> & is_reporting_enabled_callback,const StoreClientInfoCallback & store_client_info,const LoadClientInfoCallback & retrieve_client_info)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
RegisterPrefs(PrefRegistrySimple * registry)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
BackUpCurrentClientInfo()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
LoadClientInfoAndMaybeMigrate()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
GetLowEntropySource()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
ResetMetricsIDsIfNecessary()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