OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "android_webview/browser/aw_metrics_service_client.h" | 5 #include "android_webview/browser/aw_metrics_service_client.h" |
6 | 6 |
7 #include "android_webview/common/aw_version_info_values.h" | |
8 #include "base/bind.h" | |
9 #include "base/files/file_util.h" | |
10 #include "base/guid.h" | |
11 #include "base/i18n/rtl.h" | |
12 #include "components/metrics/call_stack_profile_metrics_provider.h" | |
13 #include "components/metrics/enabled_state_provider.h" | |
14 #include "components/metrics/gpu/gpu_metrics_provider.h" | |
15 #include "components/metrics/metrics_pref_names.h" | |
16 #include "components/metrics/metrics_service.h" | |
17 #include "components/metrics/metrics_state_manager.h" | |
18 #include "components/metrics/net/net_metrics_log_uploader.h" | |
19 #include "components/metrics/profiler/profiler_metrics_provider.h" | |
20 #include "components/metrics/ui/screen_info_metrics_provider.h" | |
21 #include "components/metrics/url_constants.h" | |
22 #include "components/prefs/pref_service.h" | |
23 #include "content/public/browser/browser_thread.h" | |
24 | |
25 namespace android_webview { | 7 namespace android_webview { |
26 | 8 |
27 base::LazyInstance<AwMetricsServiceClient>::Leaky g_lazy_instance_; | 9 AwMetricsServiceClient::AwMetricsServiceClient() {} |
28 | |
29 namespace { | |
30 | |
31 const int kUploadIntervalMinutes = 30; | |
32 | |
33 // Callbacks for metrics::MetricsStateManager::Create. Store/LoadClientInfo | |
34 // allow Windows Chrome to back up ClientInfo. They're no-ops for WebView. | |
35 | |
36 void StoreClientInfo(const metrics::ClientInfo& client_info) {} | |
37 | |
38 std::unique_ptr<metrics::ClientInfo> LoadClientInfo() { | |
39 std::unique_ptr<metrics::ClientInfo> client_info; | |
40 return client_info; | |
41 } | |
42 | |
43 // A GUID in text form is composed of 32 hex digits and 4 hyphens. | |
44 const size_t GUID_SIZE = 32 + 4; | |
45 | |
46 void GetOrCreateGUID(const base::FilePath guid_file_path, std::string* guid) { | |
47 DCHECK_CURRENTLY_ON(content::BrowserThread::FILE); | |
48 | |
49 // Try to read an existing GUID. | |
50 if (base::ReadFileToStringWithMaxSize(guid_file_path, guid, GUID_SIZE)) { | |
51 if (base::IsValidGUID(*guid)) | |
52 return; | |
53 else | |
54 LOG(ERROR) << "Found invalid GUID"; | |
55 } | |
56 | |
57 // We must write a new GUID. | |
58 *guid = base::GenerateGUID(); | |
59 if (!base::WriteFile(guid_file_path, guid->c_str(), guid->size())) | |
60 LOG(ERROR) << "Failed to write new GUID"; | |
61 return; | |
62 } | |
63 | |
64 } // namespace | |
65 | |
66 // static | |
67 AwMetricsServiceClient* AwMetricsServiceClient::GetInstance() { | |
68 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | |
69 return g_lazy_instance_.Pointer(); | |
70 } | |
71 | |
72 void AwMetricsServiceClient::Initialize( | |
73 PrefService* pref_service, | |
74 net::URLRequestContextGetter* request_context, | |
75 const base::FilePath guid_file_path) { | |
76 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | |
77 DCHECK(!is_initialized_); | |
78 | |
79 pref_service_ = pref_service; | |
80 request_context_ = request_context; | |
81 | |
82 std::string* guid = new std::string; | |
83 // Initialization happens on the UI thread, but getting the GUID should happen | |
84 // on the file I/O thread. So we start to initialize, then post to get the | |
85 // GUID, and then pick up where we left off, back on the UI thread, in | |
86 // InitializeWithGUID. | |
87 content::BrowserThread::PostTaskAndReply( | |
88 content::BrowserThread::FILE, | |
89 FROM_HERE, | |
90 base::Bind(&GetOrCreateGUID, guid_file_path, guid), | |
91 base::Bind(&AwMetricsServiceClient::InitializeWithGUID, | |
92 base::Unretained(this), base::Owned(guid))); | |
93 } | |
94 | |
95 void AwMetricsServiceClient::InitializeWithGUID(std::string* guid) { | |
96 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | |
97 DCHECK(!is_initialized_); | |
98 | |
99 pref_service_->SetString(metrics::prefs::kMetricsClientID, *guid); | |
100 | |
101 metrics_state_manager_ = metrics::MetricsStateManager::Create( | |
102 pref_service_, this, base::Bind(&StoreClientInfo), | |
103 base::Bind(&LoadClientInfo)); | |
104 | |
105 metrics_service_.reset(new ::metrics::MetricsService( | |
106 metrics_state_manager_.get(), this, pref_service_)); | |
107 | |
108 metrics_service_->RegisterMetricsProvider( | |
109 std::unique_ptr<metrics::MetricsProvider>( | |
110 new metrics::NetworkMetricsProvider( | |
111 content::BrowserThread::GetBlockingPool()))); | |
112 | |
113 metrics_service_->RegisterMetricsProvider( | |
114 std::unique_ptr<metrics::MetricsProvider>( | |
115 new metrics::GPUMetricsProvider)); | |
116 | |
117 metrics_service_->RegisterMetricsProvider( | |
118 std::unique_ptr<metrics::MetricsProvider>( | |
119 new metrics::ScreenInfoMetricsProvider)); | |
120 | |
121 metrics_service_->RegisterMetricsProvider( | |
122 std::unique_ptr<metrics::MetricsProvider>( | |
123 new metrics::ProfilerMetricsProvider())); | |
124 | |
125 metrics_service_->RegisterMetricsProvider( | |
126 std::unique_ptr<metrics::MetricsProvider>( | |
127 new metrics::CallStackProfileMetricsProvider)); | |
128 | |
129 metrics_service_->InitializeMetricsRecordingState(); | |
130 | |
131 is_initialized_ = true; | |
132 | |
133 if (IsReportingEnabled()) | |
134 metrics_service_->Start(); | |
135 } | |
136 | |
137 void AwMetricsServiceClient::SetMetricsEnabled(bool enabled) { | |
138 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | |
139 | |
140 // If the client is already initialized, apply the setting immediately. | |
141 // Otherwise, it will be applied on initialization. | |
142 if (is_initialized_ && is_enabled_ != enabled) { | |
143 if (enabled) | |
144 metrics_service_->Start(); | |
145 else | |
146 metrics_service_->Stop(); | |
147 } | |
148 is_enabled_ = enabled; | |
149 } | |
150 | |
151 bool AwMetricsServiceClient::IsConsentGiven() { | |
152 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | |
153 return is_enabled_; | |
154 } | |
155 | |
156 metrics::MetricsService* AwMetricsServiceClient::GetMetricsService() { | |
157 return metrics_service_.get(); | |
158 } | |
159 | |
160 // In Chrome, UMA and Breakpad are enabled/disabled together by the same | |
161 // checkbox and they share the same client ID (a.k.a. GUID). SetMetricsClientId | |
162 // is intended to provide the ID to Breakpad. In WebView, UMA and Breakpad are | |
163 // independent, so this is a no-op. | |
164 | |
165 void AwMetricsServiceClient::SetMetricsClientId(const std::string& client_id) {} | |
166 | |
167 int32_t AwMetricsServiceClient::GetProduct() { | |
168 return ::metrics::ChromeUserMetricsExtension::ANDROID_WEBVIEW; | |
169 } | |
170 | |
171 std::string AwMetricsServiceClient::GetApplicationLocale() { | |
172 return base::i18n::GetConfiguredLocale(); | |
173 } | |
174 | |
175 bool AwMetricsServiceClient::GetBrand(std::string* brand_code) { | |
176 // WebView doesn't use brand codes. | |
177 return false; | |
178 } | |
179 | |
180 metrics::SystemProfileProto::Channel AwMetricsServiceClient::GetChannel() { | |
181 // "Channel" means stable, beta, etc. WebView doesn't have channel info yet. | |
182 // TODO(paulmiller) Update this once we have channel info. | |
183 return metrics::SystemProfileProto::CHANNEL_UNKNOWN; | |
184 } | |
185 | |
186 std::string AwMetricsServiceClient::GetVersionString() { | |
187 return PRODUCT_VERSION; | |
188 } | |
189 | |
190 void AwMetricsServiceClient::InitializeSystemProfileMetrics( | |
191 const base::Closure& done_callback) { | |
192 done_callback.Run(); | |
193 } | |
194 | |
195 void AwMetricsServiceClient::CollectFinalMetricsForLog( | |
196 const base::Closure& done_callback) { | |
197 done_callback.Run(); | |
198 } | |
199 | |
200 std::unique_ptr<metrics::MetricsLogUploader> | |
201 AwMetricsServiceClient::CreateUploader( | |
202 const std::string& server_url, | |
203 const std::string& mime_type, | |
204 const base::Callback<void(int)>& on_upload_complete) { | |
205 return std::unique_ptr<::metrics::MetricsLogUploader>( | |
206 new metrics::NetMetricsLogUploader( | |
207 request_context_, server_url, mime_type, on_upload_complete)); | |
208 } | |
209 | |
210 base::TimeDelta AwMetricsServiceClient::GetStandardUploadInterval() { | |
211 return base::TimeDelta::FromMinutes(kUploadIntervalMinutes); | |
212 } | |
213 | |
214 AwMetricsServiceClient::AwMetricsServiceClient() | |
215 : is_initialized_(false), | |
216 is_enabled_(false), | |
217 pref_service_(nullptr), | |
218 request_context_(nullptr) {} | |
219 | 10 |
220 AwMetricsServiceClient::~AwMetricsServiceClient() {} | 11 AwMetricsServiceClient::~AwMetricsServiceClient() {} |
221 | 12 |
222 } // namespace android_webview | 13 } // namespace android_webview |
OLD | NEW |