OLD | NEW |
| (Empty) |
1 // Copyright 2017 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 "android_webview/browser/aw_metrics_service_client_impl.h" | |
6 | |
7 #include "android_webview/browser/aw_metrics_log_uploader.h" | |
8 #include "android_webview/common/aw_version_info_values.h" | |
9 #include "android_webview/jni/AwMetricsServiceClient_jni.h" | |
10 #include "base/android/build_info.h" | |
11 #include "base/bind.h" | |
12 #include "base/files/file_util.h" | |
13 #include "base/guid.h" | |
14 #include "base/i18n/rtl.h" | |
15 #include "base/threading/sequenced_worker_pool.h" | |
16 #include "components/metrics/call_stack_profile_metrics_provider.h" | |
17 #include "components/metrics/enabled_state_provider.h" | |
18 #include "components/metrics/gpu/gpu_metrics_provider.h" | |
19 #include "components/metrics/metrics_log_uploader.h" | |
20 #include "components/metrics/metrics_pref_names.h" | |
21 #include "components/metrics/metrics_service.h" | |
22 #include "components/metrics/metrics_state_manager.h" | |
23 #include "components/metrics/profiler/profiler_metrics_provider.h" | |
24 #include "components/metrics/ui/screen_info_metrics_provider.h" | |
25 #include "components/metrics/url_constants.h" | |
26 #include "components/prefs/pref_service.h" | |
27 #include "content/public/browser/browser_thread.h" | |
28 | |
29 namespace android_webview { | |
30 | |
31 base::LazyInstance<AwMetricsServiceClientImpl>::Leaky g_lazy_instance_; | |
32 | |
33 namespace { | |
34 | |
35 const int kUploadIntervalMinutes = 30; | |
36 | |
37 // Callbacks for metrics::MetricsStateManager::Create. Store/LoadClientInfo | |
38 // allow Windows Chrome to back up ClientInfo. They're no-ops for WebView. | |
39 | |
40 void StoreClientInfo(const metrics::ClientInfo& client_info) {} | |
41 | |
42 std::unique_ptr<metrics::ClientInfo> LoadClientInfo() { | |
43 std::unique_ptr<metrics::ClientInfo> client_info; | |
44 return client_info; | |
45 } | |
46 | |
47 // A GUID in text form is composed of 32 hex digits and 4 hyphens. | |
48 const size_t GUID_SIZE = 32 + 4; | |
49 | |
50 void GetOrCreateGUID(const base::FilePath guid_file_path, std::string* guid) { | |
51 DCHECK_CURRENTLY_ON(content::BrowserThread::FILE); | |
52 | |
53 // Try to read an existing GUID. | |
54 if (base::ReadFileToStringWithMaxSize(guid_file_path, guid, GUID_SIZE)) { | |
55 if (base::IsValidGUID(*guid)) | |
56 return; | |
57 else | |
58 LOG(ERROR) << "Overwriting invalid GUID"; | |
59 } | |
60 | |
61 // We must write a new GUID. | |
62 *guid = base::GenerateGUID(); | |
63 if (!base::WriteFile(guid_file_path, guid->c_str(), guid->size())) { | |
64 // If writing fails, proceed anyway with the new GUID. It won't be persisted | |
65 // to the next run, but we can still collect metrics with this 1-time GUID. | |
66 LOG(ERROR) << "Failed to write new GUID"; | |
67 } | |
68 return; | |
69 } | |
70 | |
71 } // namespace | |
72 | |
73 // static | |
74 AwMetricsServiceClient* AwMetricsServiceClient::GetInstance() { | |
75 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | |
76 return g_lazy_instance_.Pointer(); | |
77 } | |
78 | |
79 void AwMetricsServiceClientImpl::Initialize( | |
80 PrefService* pref_service, | |
81 net::URLRequestContextGetter* request_context, | |
82 const base::FilePath guid_file_path) { | |
83 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | |
84 | |
85 DCHECK(pref_service_ == nullptr); // Initialize should only happen once. | |
86 DCHECK(request_context_ == nullptr); | |
87 pref_service_ = pref_service; | |
88 request_context_ = request_context; | |
89 | |
90 std::string* guid = new std::string; | |
91 // Initialization happens on the UI thread, but getting the GUID should happen | |
92 // on the file I/O thread. So we start to initialize, then post to get the | |
93 // GUID, and then pick up where we left off, back on the UI thread, in | |
94 // InitializeWithGUID. | |
95 content::BrowserThread::PostTaskAndReply( | |
96 content::BrowserThread::FILE, FROM_HERE, | |
97 base::Bind(&GetOrCreateGUID, guid_file_path, guid), | |
98 base::Bind(&AwMetricsServiceClientImpl::InitializeWithGUID, | |
99 base::Unretained(this), base::Owned(guid))); | |
100 } | |
101 | |
102 void AwMetricsServiceClientImpl::InitializeWithGUID(std::string* guid) { | |
103 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | |
104 | |
105 pref_service_->SetString(metrics::prefs::kMetricsClientID, *guid); | |
106 | |
107 metrics_state_manager_ = metrics::MetricsStateManager::Create( | |
108 pref_service_, this, base::Bind(&StoreClientInfo), | |
109 base::Bind(&LoadClientInfo)); | |
110 | |
111 metrics_service_.reset(new ::metrics::MetricsService( | |
112 metrics_state_manager_.get(), this, pref_service_)); | |
113 | |
114 metrics_service_->RegisterMetricsProvider( | |
115 std::unique_ptr<metrics::MetricsProvider>( | |
116 new metrics::NetworkMetricsProvider( | |
117 content::BrowserThread::GetBlockingPool()))); | |
118 | |
119 metrics_service_->RegisterMetricsProvider( | |
120 std::unique_ptr<metrics::MetricsProvider>( | |
121 new metrics::GPUMetricsProvider)); | |
122 | |
123 metrics_service_->RegisterMetricsProvider( | |
124 std::unique_ptr<metrics::MetricsProvider>( | |
125 new metrics::ScreenInfoMetricsProvider)); | |
126 | |
127 metrics_service_->RegisterMetricsProvider( | |
128 std::unique_ptr<metrics::MetricsProvider>( | |
129 new metrics::ProfilerMetricsProvider())); | |
130 | |
131 metrics_service_->RegisterMetricsProvider( | |
132 std::unique_ptr<metrics::MetricsProvider>( | |
133 new metrics::CallStackProfileMetricsProvider)); | |
134 | |
135 metrics_service_->InitializeMetricsRecordingState(); | |
136 | |
137 JNIEnv* env = base::android::AttachCurrentThread(); | |
138 Java_AwMetricsServiceClient_nativeInitialized(env); | |
139 } | |
140 | |
141 bool AwMetricsServiceClientImpl::IsConsentGiven() { | |
142 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | |
143 return is_enabled_; | |
144 } | |
145 | |
146 void AwMetricsServiceClientImpl::SetMetricsEnabled(bool enabled) { | |
147 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | |
148 | |
149 // For now, UMA is only enabled on Android N+. | |
150 if (base::android::BuildInfo::GetInstance()->sdk_int() < | |
151 base::android::SDK_VERSION_NOUGAT) { | |
152 return; | |
153 } | |
154 | |
155 if (is_enabled_ != enabled) { | |
156 if (enabled) { | |
157 metrics_service_->Start(); | |
158 } else { | |
159 metrics_service_->Stop(); | |
160 } | |
161 is_enabled_ = enabled; | |
162 } | |
163 } | |
164 | |
165 metrics::MetricsService* AwMetricsServiceClientImpl::GetMetricsService() { | |
166 return metrics_service_.get(); | |
167 } | |
168 | |
169 // In Chrome, UMA and Breakpad are enabled/disabled together by the same | |
170 // checkbox and they share the same client ID (a.k.a. GUID). SetMetricsClientId | |
171 // is intended to provide the ID to Breakpad. In WebView, UMA and Breakpad are | |
172 // independent, so this is a no-op. | |
173 void AwMetricsServiceClientImpl::SetMetricsClientId( | |
174 const std::string& client_id) {} | |
175 | |
176 int32_t AwMetricsServiceClientImpl::GetProduct() { | |
177 return ::metrics::ChromeUserMetricsExtension::ANDROID_WEBVIEW; | |
178 } | |
179 | |
180 std::string AwMetricsServiceClientImpl::GetApplicationLocale() { | |
181 return base::i18n::GetConfiguredLocale(); | |
182 } | |
183 | |
184 bool AwMetricsServiceClientImpl::GetBrand(std::string* brand_code) { | |
185 // WebView doesn't use brand codes. | |
186 return false; | |
187 } | |
188 | |
189 metrics::SystemProfileProto::Channel AwMetricsServiceClientImpl::GetChannel() { | |
190 // "Channel" means stable, beta, etc. WebView doesn't have channel info yet. | |
191 // TODO(paulmiller) Update this once we have channel info. | |
192 return metrics::SystemProfileProto::CHANNEL_UNKNOWN; | |
193 } | |
194 | |
195 std::string AwMetricsServiceClientImpl::GetVersionString() { | |
196 return PRODUCT_VERSION; | |
197 } | |
198 | |
199 void AwMetricsServiceClientImpl::InitializeSystemProfileMetrics( | |
200 const base::Closure& done_callback) { | |
201 done_callback.Run(); | |
202 } | |
203 | |
204 void AwMetricsServiceClientImpl::CollectFinalMetricsForLog( | |
205 const base::Closure& done_callback) { | |
206 done_callback.Run(); | |
207 } | |
208 | |
209 std::unique_ptr<metrics::MetricsLogUploader> | |
210 AwMetricsServiceClientImpl::CreateUploader( | |
211 base::StringPiece server_url, | |
212 base::StringPiece mime_type, | |
213 metrics::MetricsLogUploader::MetricServiceType service_type, | |
214 const metrics::MetricsLogUploader::UploadCallback& on_upload_complete) { | |
215 // |server_url| and |mime_type| are unused because WebView uses the platform | |
216 // logging mechanism instead of the normal UMA server. | |
217 return std::unique_ptr<::metrics::MetricsLogUploader>( | |
218 new AwMetricsLogUploader(on_upload_complete)); | |
219 } | |
220 | |
221 base::TimeDelta AwMetricsServiceClientImpl::GetStandardUploadInterval() { | |
222 // The platform logging mechanism is responsible for upload frequency; this | |
223 // just specifies how frequently to provide logs to the platform. | |
224 return base::TimeDelta::FromMinutes(kUploadIntervalMinutes); | |
225 } | |
226 | |
227 AwMetricsServiceClientImpl::AwMetricsServiceClientImpl() | |
228 : is_enabled_(false), pref_service_(nullptr), request_context_(nullptr) {} | |
229 | |
230 AwMetricsServiceClientImpl::~AwMetricsServiceClientImpl() {} | |
231 | |
232 // static | |
233 void SetMetricsEnabled(JNIEnv* env, | |
234 const base::android::JavaParamRef<jclass>& jcaller, | |
235 jboolean enabled) { | |
236 g_lazy_instance_.Pointer()->SetMetricsEnabled(enabled); | |
237 } | |
238 | |
239 bool RegisterAwMetricsServiceClient(JNIEnv* env) { | |
240 return RegisterNativesImpl(env); | |
241 } | |
242 | |
243 } // namespace android_webview | |
OLD | NEW |