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