OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 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 | 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/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 |
7 namespace android_webview { | 29 namespace android_webview { |
8 | 30 |
9 AwMetricsServiceClient::AwMetricsServiceClient() {} | 31 base::LazyInstance<AwMetricsServiceClient>::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 AwMetricsServiceClient::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(&AwMetricsServiceClient::InitializeWithGUID, |
| 99 base::Unretained(this), base::Owned(guid))); |
| 100 } |
| 101 |
| 102 void AwMetricsServiceClient::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 AwMetricsServiceClient::IsConsentGiven() { |
| 142 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| 143 return is_enabled_; |
| 144 } |
| 145 |
| 146 void AwMetricsServiceClient::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* AwMetricsServiceClient::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 AwMetricsServiceClient::SetMetricsClientId(const std::string& client_id) {} |
| 174 |
| 175 int32_t AwMetricsServiceClient::GetProduct() { |
| 176 return ::metrics::ChromeUserMetricsExtension::ANDROID_WEBVIEW; |
| 177 } |
| 178 |
| 179 std::string AwMetricsServiceClient::GetApplicationLocale() { |
| 180 return base::i18n::GetConfiguredLocale(); |
| 181 } |
| 182 |
| 183 bool AwMetricsServiceClient::GetBrand(std::string* brand_code) { |
| 184 // WebView doesn't use brand codes. |
| 185 return false; |
| 186 } |
| 187 |
| 188 metrics::SystemProfileProto::Channel AwMetricsServiceClient::GetChannel() { |
| 189 // "Channel" means stable, beta, etc. WebView doesn't have channel info yet. |
| 190 // TODO(paulmiller) Update this once we have channel info. |
| 191 return metrics::SystemProfileProto::CHANNEL_UNKNOWN; |
| 192 } |
| 193 |
| 194 std::string AwMetricsServiceClient::GetVersionString() { |
| 195 return PRODUCT_VERSION; |
| 196 } |
| 197 |
| 198 void AwMetricsServiceClient::InitializeSystemProfileMetrics( |
| 199 const base::Closure& done_callback) { |
| 200 done_callback.Run(); |
| 201 } |
| 202 |
| 203 void AwMetricsServiceClient::CollectFinalMetricsForLog( |
| 204 const base::Closure& done_callback) { |
| 205 done_callback.Run(); |
| 206 } |
| 207 |
| 208 std::unique_ptr<metrics::MetricsLogUploader> |
| 209 AwMetricsServiceClient::CreateUploader( |
| 210 base::StringPiece server_url, |
| 211 base::StringPiece mime_type, |
| 212 metrics::MetricsLogUploader::MetricServiceType service_type, |
| 213 const metrics::MetricsLogUploader::UploadCallback& on_upload_complete) { |
| 214 // |server_url| and |mime_type| are unused because WebView uses the platform |
| 215 // logging mechanism instead of the normal UMA server. |
| 216 return std::unique_ptr<::metrics::MetricsLogUploader>( |
| 217 new AwMetricsLogUploader(on_upload_complete)); |
| 218 } |
| 219 |
| 220 base::TimeDelta AwMetricsServiceClient::GetStandardUploadInterval() { |
| 221 // The platform logging mechanism is responsible for upload frequency; this |
| 222 // just specifies how frequently to provide logs to the platform. |
| 223 return base::TimeDelta::FromMinutes(kUploadIntervalMinutes); |
| 224 } |
| 225 |
| 226 AwMetricsServiceClient::AwMetricsServiceClient() |
| 227 : is_enabled_(false), pref_service_(nullptr), request_context_(nullptr) {} |
10 | 228 |
11 AwMetricsServiceClient::~AwMetricsServiceClient() {} | 229 AwMetricsServiceClient::~AwMetricsServiceClient() {} |
12 | 230 |
| 231 // static |
| 232 void SetMetricsEnabled(JNIEnv* env, |
| 233 const base::android::JavaParamRef<jclass>& jcaller, |
| 234 jboolean enabled) { |
| 235 g_lazy_instance_.Pointer()->SetMetricsEnabled(enabled); |
| 236 } |
| 237 |
| 238 bool RegisterAwMetricsServiceClient(JNIEnv* env) { |
| 239 return RegisterNativesImpl(env); |
| 240 } |
| 241 |
13 } // namespace android_webview | 242 } // namespace android_webview |
OLD | NEW |