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