1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
// 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.
#ifndef COMPONENTS_METRICS_METRICS_STATE_MANAGER_H_
#define COMPONENTS_METRICS_METRICS_STATE_MANAGER_H_
#include <memory>
#include <string>
#include "base/callback.h"
#include "base/gtest_prod_util.h"
#include "base/macros.h"
#include "base/metrics/field_trial.h"
#include "components/metrics/client_info.h"
class PrefService;
class PrefRegistrySimple;
namespace metrics {
class ClonedInstallDetector;
class EnabledStateProvider;
// Responsible for managing MetricsService state prefs, specifically the UMA
// client id and low entropy source. Code outside the metrics directory should
// not be instantiating or using this class directly.
class MetricsStateManager {
public:
// A callback that can be invoked to store client info to persistent storage.
// Storing an empty client_id will resulted in the backup being voided.
typedef base::Callback<void(const ClientInfo& client_info)>
StoreClientInfoCallback;
// A callback that can be invoked to load client info stored through the
// StoreClientInfoCallback.
typedef base::Callback<std::unique_ptr<ClientInfo>(void)>
LoadClientInfoCallback;
virtual ~MetricsStateManager();
// Returns true if the user has consented to sending metric reports, and there
// is no other reason to disable reporting. One such reason is client
// sampling, and this client isn't in the sample.
bool IsMetricsReportingEnabled();
// Returns the client ID for this client, or the empty string if the user is
// not opted in to metrics reporting.
const std::string& client_id() const { return client_id_; }
// Forces the client ID to be generated. This is useful in case it's needed
// before recording.
void ForceClientIdCreation();
// Checks if this install was cloned or imaged from another machine. If a
// clone is detected, resets the client id and low entropy source. This
// should not be called more than once.
void CheckForClonedInstall(
scoped_refptr<base::SingleThreadTaskRunner> task_runner);
// Returns the preferred entropy provider used to seed persistent activities
// based on whether or not metrics reporting is permitted on this client.
//
// If there's consent to report metrics, this method returns an entropy
// provider that has a high source of entropy, partially based on the client
// ID. Otherwise, it returns an entropy provider that is based on a low
// entropy source.
std::unique_ptr<const base::FieldTrial::EntropyProvider>
CreateDefaultEntropyProvider();
// Returns an entropy provider that is based on a low entropy source. This
// provider is the same type of provider returned by
// CreateDefaultEntropyProvider when there's no consent to report metrics, but
// will be a new instance.
std::unique_ptr<const base::FieldTrial::EntropyProvider>
CreateLowEntropyProvider();
// Creates the MetricsStateManager, enforcing that only a single instance
// of the class exists at a time. Returns NULL if an instance exists already.
static std::unique_ptr<MetricsStateManager> Create(
PrefService* local_state,
EnabledStateProvider* enabled_state_provider,
const StoreClientInfoCallback& store_client_info,
const LoadClientInfoCallback& load_client_info);
// Registers local state prefs used by this class.
static void RegisterPrefs(PrefRegistrySimple* registry);
private:
FRIEND_TEST_ALL_PREFIXES(MetricsStateManagerTest, EntropySourceUsed_Low);
FRIEND_TEST_ALL_PREFIXES(MetricsStateManagerTest, EntropySourceUsed_High);
FRIEND_TEST_ALL_PREFIXES(MetricsStateManagerTest, LowEntropySource0NotReset);
FRIEND_TEST_ALL_PREFIXES(MetricsStateManagerTest,
PermutedEntropyCacheClearedWhenLowEntropyReset);
FRIEND_TEST_ALL_PREFIXES(MetricsStateManagerTest, ResetMetricsIDs);
// Designates which entropy source was returned from this class.
// This is used for testing to validate that we return the correct source
// depending on the state of the service.
enum EntropySourceType {
ENTROPY_SOURCE_NONE,
ENTROPY_SOURCE_LOW,
ENTROPY_SOURCE_HIGH,
ENTROPY_SOURCE_ENUM_SIZE,
};
// Creates the MetricsStateManager with the given |local_state|. Uses
// |enabled_state_provider| to query whether there is consent for metrics
// reporting, and if it is enabled. Clients should instead use Create(), which
// enforces that a single instance of this class be alive at any given time.
// |store_client_info| should back up client info to persistent storage such
// that it is later retrievable by |load_client_info|.
MetricsStateManager(PrefService* local_state,
EnabledStateProvider* enabled_state_provider,
const StoreClientInfoCallback& store_client_info,
const LoadClientInfoCallback& load_client_info);
// Backs up the current client info via |store_client_info_|.
void BackUpCurrentClientInfo();
// Loads the client info via |load_client_info_| and potentially migrates it
// before returning it if it comes back in its old form.
std::unique_ptr<ClientInfo> LoadClientInfoAndMaybeMigrate();
// Returns the low entropy source for this client. This is a random value
// that is non-identifying amongst browser clients. This method will
// generate the entropy source value if it has not been called before.
int GetLowEntropySource();
// Generates the low entropy source value for this client if it is not
// already set.
void UpdateLowEntropySource();
// Updates |entropy_source_returned_| with |type| iff the current value is
// ENTROPY_SOURCE_NONE and logs the new value in a histogram.
void UpdateEntropySourceReturnedValue(EntropySourceType type);
// Returns the first entropy source that was returned by this service since
// start up, or NONE if neither was returned yet. This is exposed for testing
// only.
EntropySourceType entropy_source_returned() const {
return entropy_source_returned_;
}
// Reset the client id and low entropy source if the kMetricsResetMetricIDs
// pref is true.
void ResetMetricsIDsIfNecessary();
// Whether an instance of this class exists. Used to enforce that there aren't
// multiple instances of this class at a given time.
static bool instance_exists_;
// Weak pointer to the local state prefs store.
PrefService* const local_state_;
// Weak pointer to an enabled state provider. Used to know whether the user
// has consented to reporting, and if reporting should be done.
EnabledStateProvider* enabled_state_provider_;
// A callback run during client id creation so this MetricsStateManager can
// store a backup of the newly generated ID.
const StoreClientInfoCallback store_client_info_;
// A callback run if this MetricsStateManager can't get the client id from
// its typical location and wants to attempt loading it from this backup.
const LoadClientInfoCallback load_client_info_;
// The identifier that's sent to the server with the log reports.
std::string client_id_;
// The non-identifying low entropy source value.
int low_entropy_source_;
// The last entropy source returned by this service, used for testing.
EntropySourceType entropy_source_returned_;
std::unique_ptr<ClonedInstallDetector> cloned_install_detector_;
DISALLOW_COPY_AND_ASSIGN(MetricsStateManager);
};
} // namespace metrics
#endif // COMPONENTS_METRICS_METRICS_STATE_MANAGER_H_
|
