OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2016 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 "blimp/engine/app/blimp_metrics_service_client.h" | |
6 | |
7 #include "base/bind.h" | |
8 #include "base/i18n/rtl.h" | |
9 #include "base/lazy_instance.h" | |
10 #include "base/memory/ptr_util.h" | |
11 #include "base/memory/ref_counted.h" | |
12 #include "components/metrics/call_stack_profile_metrics_provider.h" | |
13 #include "components/metrics/gpu/gpu_metrics_provider.h" | |
14 #include "components/metrics/metrics_service.h" | |
15 #include "components/metrics/metrics_service_client.h" | |
16 #include "components/metrics/metrics_state_manager.h" | |
17 #include "components/metrics/net/net_metrics_log_uploader.h" | |
18 #include "components/metrics/profiler/profiler_metrics_provider.h" | |
19 #include "components/metrics/ui/screen_info_metrics_provider.h" | |
20 #include "components/metrics/url_constants.h" | |
21 #include "components/prefs/pref_service.h" | |
22 #include "content/public/browser/browser_thread.h" | |
23 #include "net/url_request/url_request_context_getter.h" | |
24 | |
25 namespace blimp { | |
26 namespace engine { | |
27 | |
28 // BlimpMetricsServiceClient provides a singleton implementation of | |
29 // MetricsServiceClient tailored for the Blimp engine. | |
30 // Metrics are always turned on. | |
31 class BlimpMetricsServiceClient : public metrics::MetricsServiceClient { | |
32 friend struct base::DefaultLazyInstanceTraits<BlimpMetricsServiceClient>; | |
33 | |
34 public: | |
35 // The request_context_getter is a system request context that must remain | |
36 // valid for the client lifetime. | |
37 void Initialize(PrefService* pref_service, | |
38 net::URLRequestContextGetter* request_context_getter); | |
39 void Finalize(); | |
40 | |
41 // metrics::MetricsServiceClient implementation. | |
42 metrics::MetricsService* GetMetricsService() override; | |
43 void SetMetricsClientId(const std::string& client_id) override; | |
44 void OnRecordingDisabled() override; | |
45 bool IsOffTheRecordSessionActive() override; | |
46 int32_t GetProduct() override; | |
47 std::string GetApplicationLocale() override; | |
48 bool GetBrand(std::string* brand_code) override; | |
49 metrics::SystemProfileProto::Channel GetChannel() override; | |
50 std::string GetVersionString() override; | |
51 void OnLogUploadComplete() override; | |
52 void InitializeSystemProfileMetrics( | |
53 const base::Closure& done_callback) override; | |
54 void CollectFinalMetricsForLog(const base::Closure& done_callback) override; | |
55 std::unique_ptr<metrics::MetricsLogUploader> CreateUploader( | |
56 const base::Callback<void(int)>& on_upload_complete) override; | |
57 base::TimeDelta GetStandardUploadInterval() override; | |
58 metrics::MetricsServiceClient::EnableMetricsDefault GetDefaultOptIn() | |
59 override; | |
60 | |
61 private: | |
62 BlimpMetricsServiceClient(); | |
63 ~BlimpMetricsServiceClient() override; | |
64 | |
65 bool is_initialized_ = false; | |
66 // Used by NetMetricsLogUploader to create log-upload requests. | |
67 scoped_refptr<net::URLRequestContextGetter> request_context_getter_; | |
68 std::unique_ptr<metrics::MetricsStateManager> metrics_state_manager_; | |
69 std::unique_ptr<metrics::MetricsService> metrics_service_; | |
70 | |
71 DISALLOW_COPY_AND_ASSIGN(BlimpMetricsServiceClient); | |
72 }; | |
73 | |
74 namespace { | |
75 | |
76 // How often after initial logging metrics results should be uploaded to the | |
77 // metrics service. | |
78 const int kStandardUploadIntervalMinutes = 30; | |
79 | |
80 base::LazyInstance<BlimpMetricsServiceClient>::Leaky g_lazy_instance_; | |
81 | |
82 // Returns if the MetricsService should be recording metrics information for | |
83 // the client. | |
84 // This callback required by MetricsStateManager::Create. | |
85 bool IsReportingEnabled() { | |
86 return true; | |
87 } | |
88 | |
89 // Store/LoadClientInfo allows Windows Chrome to back up ClientInfo. | |
90 // Both are no-ops for Blimp. | |
91 // These callbacks are required by MetricsStateManager::Create. | |
92 void StoreClientInfo(const metrics::ClientInfo& client_info) {} | |
93 | |
94 std::unique_ptr<metrics::ClientInfo> LoadClientInfo() { | |
95 return nullptr; | |
96 } | |
97 | |
98 } // namespace | |
99 | |
100 void BlimpMetricsServiceClient::Initialize( | |
101 PrefService* pref_service, | |
102 net::URLRequestContextGetter* request_context_getter) { | |
103 DCHECK(!is_initialized_); | |
104 request_context_getter_ = request_context_getter; | |
105 | |
106 metrics_state_manager_ = metrics::MetricsStateManager::Create( | |
107 pref_service, base::Bind(&IsReportingEnabled), | |
108 base::Bind(&StoreClientInfo), base::Bind(&LoadClientInfo)); | |
109 | |
110 metrics_service_.reset(new metrics::MetricsService( | |
111 metrics_state_manager_.get(), this, pref_service)); | |
112 | |
113 metrics_service_->RegisterMetricsProvider( | |
114 base::WrapUnique<metrics::MetricsProvider>( | |
115 new metrics::NetworkMetricsProvider( | |
116 content::BrowserThread::GetBlockingPool()))); | |
117 | |
118 metrics_service_->RegisterMetricsProvider( | |
119 base::WrapUnique<metrics::MetricsProvider>( | |
120 new metrics::GPUMetricsProvider)); | |
121 | |
122 metrics_service_->RegisterMetricsProvider( | |
123 base::WrapUnique<metrics::MetricsProvider>( | |
124 new metrics::ScreenInfoMetricsProvider)); | |
125 | |
126 metrics_service_->RegisterMetricsProvider( | |
127 base::WrapUnique<metrics::MetricsProvider>( | |
128 new metrics::ProfilerMetricsProvider())); | |
129 | |
130 metrics_service_->RegisterMetricsProvider( | |
131 base::WrapUnique<metrics::MetricsProvider>( | |
132 new metrics::CallStackProfileMetricsProvider)); | |
133 | |
134 metrics_service_->InitializeMetricsRecordingState(); | |
135 | |
136 is_initialized_ = true; | |
137 | |
138 if (IsReportingEnabled()) { | |
Alexei Svitkine (slow)
2016/04/28 16:58:26
Nit: No {}'s
Jess
2016/04/29 22:20:13
Done.
| |
139 metrics_service_->Start(); | |
140 } | |
141 } | |
142 | |
143 void BlimpMetricsServiceClient::Finalize() { | |
144 DCHECK(is_initialized_); | |
145 metrics_service_->Stop(); | |
146 } | |
147 | |
148 metrics::MetricsService* BlimpMetricsServiceClient::GetMetricsService() { | |
149 return metrics_service_.get(); | |
150 } | |
151 | |
152 // In Chrome, UMA and Breakpad are enabled/disabled together by the same | |
153 // checkbox and they share the same client ID (a.k.a. GUID). | |
154 // This is not required by Blimp, so these are no-ops. | |
155 void BlimpMetricsServiceClient::SetMetricsClientId( | |
156 const std::string& client_id) {} | |
157 | |
158 // Recording can not be disabled in Blimp, so this function is a no-op. | |
159 void BlimpMetricsServiceClient::OnRecordingDisabled() {} | |
160 | |
161 bool BlimpMetricsServiceClient::IsOffTheRecordSessionActive() { | |
162 // Blimp does not have incognito mode. | |
163 return false; | |
164 } | |
165 | |
166 int32_t BlimpMetricsServiceClient::GetProduct() { | |
167 // Indicates product family (e.g. Chrome v Android Webview), not reported | |
168 // platform (e.g. Chrome_Linux, Chrome_Mac). | |
169 return metrics::ChromeUserMetricsExtension::CHROME; | |
170 } | |
171 | |
172 std::string BlimpMetricsServiceClient::GetApplicationLocale() { | |
173 return base::i18n::GetConfiguredLocale(); | |
174 } | |
175 | |
176 bool BlimpMetricsServiceClient::GetBrand(std::string* brand_code) { | |
177 // Blimp doesn't use brand codes. | |
178 return false; | |
179 } | |
180 | |
181 metrics::SystemProfileProto::Channel BlimpMetricsServiceClient::GetChannel() { | |
182 // Blimp engine does not have channel info yet. | |
183 return metrics::SystemProfileProto::CHANNEL_UNKNOWN; | |
184 } | |
185 | |
186 std::string BlimpMetricsServiceClient::GetVersionString() { | |
187 // TODO(jessicag): Add in a meaningful version string. | |
188 return std::string(); | |
189 } | |
190 | |
191 void BlimpMetricsServiceClient::OnLogUploadComplete() {} | |
192 | |
193 void BlimpMetricsServiceClient::InitializeSystemProfileMetrics( | |
194 const base::Closure& done_callback) { | |
195 // Blimp requires no additional work to InitializeSystemProfileMetrics | |
196 // and should proceed to the next call in the chain. | |
197 done_callback.Run(); | |
198 } | |
199 | |
200 void BlimpMetricsServiceClient::CollectFinalMetricsForLog( | |
201 const base::Closure& done_callback) { | |
202 // Blimp requires no additional work to CollectFinalMetricsForLog | |
203 // and should proceed to the next call in the chain | |
204 done_callback.Run(); | |
205 } | |
206 | |
207 std::unique_ptr<metrics::MetricsLogUploader> | |
208 BlimpMetricsServiceClient::CreateUploader( | |
209 const base::Callback<void(int)>& on_upload_complete) { | |
210 return base::WrapUnique<metrics::MetricsLogUploader>( | |
211 new metrics::NetMetricsLogUploader( | |
212 request_context_getter_.get(), metrics::kDefaultMetricsServerUrl, | |
213 metrics::kDefaultMetricsMimeType, on_upload_complete)); | |
214 } | |
215 | |
216 base::TimeDelta BlimpMetricsServiceClient::GetStandardUploadInterval() { | |
217 return base::TimeDelta::FromMinutes(kStandardUploadIntervalMinutes); | |
218 } | |
219 | |
220 metrics::MetricsServiceClient::EnableMetricsDefault | |
221 BlimpMetricsServiceClient::GetDefaultOptIn() { | |
222 return OPT_IN; | |
223 } | |
224 | |
225 BlimpMetricsServiceClient::BlimpMetricsServiceClient() {} | |
226 | |
227 BlimpMetricsServiceClient::~BlimpMetricsServiceClient() {} | |
228 | |
229 BlimpMetricsServiceClient* GetBlimpMetricsServiceClientInstance() { | |
230 return g_lazy_instance_.Pointer(); | |
231 } | |
232 | |
233 void InitializeBlimpMetricsServiceClient( | |
234 PrefService* pref_service, | |
235 net::URLRequestContextGetter* request_context_getter) { | |
236 GetBlimpMetricsServiceClientInstance()->Initialize(pref_service, | |
237 request_context_getter); | |
238 } | |
239 | |
240 void FinalizeBlimpMetricsServiceClient() { | |
241 GetBlimpMetricsServiceClientInstance()->Finalize(); | |
242 } | |
243 | |
244 } // namespace engine | |
245 } // namespace blimp | |
OLD | NEW |