| 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/native/aw_metrics_service_client_impl.h" | |
| 6 | |
| 7 #include "android_webview/common/aw_version_info_values.h" | |
| 8 #include "android_webview/jni/AwMetricsServiceClient_jni.h" | |
| 9 #include "android_webview/native/aw_metrics_log_uploader.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, | |
| 97 FROM_HERE, | |
| 98 base::Bind(&GetOrCreateGUID, guid_file_path, guid), | |
| 99 base::Bind(&AwMetricsServiceClientImpl::InitializeWithGUID, | |
| 100 base::Unretained(this), base::Owned(guid))); | |
| 101 } | |
| 102 | |
| 103 void AwMetricsServiceClientImpl::InitializeWithGUID(std::string* guid) { | |
| 104 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | |
| 105 | |
| 106 pref_service_->SetString(metrics::prefs::kMetricsClientID, *guid); | |
| 107 | |
| 108 metrics_state_manager_ = metrics::MetricsStateManager::Create( | |
| 109 pref_service_, this, base::Bind(&StoreClientInfo), | |
| 110 base::Bind(&LoadClientInfo)); | |
| 111 | |
| 112 metrics_service_.reset(new ::metrics::MetricsService( | |
| 113 metrics_state_manager_.get(), this, pref_service_)); | |
| 114 | |
| 115 metrics_service_->RegisterMetricsProvider( | |
| 116 std::unique_ptr<metrics::MetricsProvider>( | |
| 117 new metrics::NetworkMetricsProvider( | |
| 118 content::BrowserThread::GetBlockingPool()))); | |
| 119 | |
| 120 metrics_service_->RegisterMetricsProvider( | |
| 121 std::unique_ptr<metrics::MetricsProvider>( | |
| 122 new metrics::GPUMetricsProvider)); | |
| 123 | |
| 124 metrics_service_->RegisterMetricsProvider( | |
| 125 std::unique_ptr<metrics::MetricsProvider>( | |
| 126 new metrics::ScreenInfoMetricsProvider)); | |
| 127 | |
| 128 metrics_service_->RegisterMetricsProvider( | |
| 129 std::unique_ptr<metrics::MetricsProvider>( | |
| 130 new metrics::ProfilerMetricsProvider())); | |
| 131 | |
| 132 metrics_service_->RegisterMetricsProvider( | |
| 133 std::unique_ptr<metrics::MetricsProvider>( | |
| 134 new metrics::CallStackProfileMetricsProvider)); | |
| 135 | |
| 136 metrics_service_->InitializeMetricsRecordingState(); | |
| 137 | |
| 138 JNIEnv* env = base::android::AttachCurrentThread(); | |
| 139 Java_AwMetricsServiceClient_nativeInitialized(env); | |
| 140 } | |
| 141 | |
| 142 bool AwMetricsServiceClientImpl::IsConsentGiven() { | |
| 143 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | |
| 144 return is_enabled_; | |
| 145 } | |
| 146 | |
| 147 void AwMetricsServiceClientImpl::SetMetricsEnabled(bool enabled) { | |
| 148 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | |
| 149 | |
| 150 // For now, UMA is only enabled on Android N+. | |
| 151 if (base::android::BuildInfo::GetInstance()->sdk_int() < | |
| 152 base::android::SDK_VERSION_NOUGAT) { | |
| 153 return; | |
| 154 } | |
| 155 | |
| 156 if (is_enabled_ != enabled) { | |
| 157 if (enabled) { | |
| 158 metrics_service_->Start(); | |
| 159 } else { | |
| 160 metrics_service_->Stop(); | |
| 161 } | |
| 162 is_enabled_ = enabled; | |
| 163 } | |
| 164 } | |
| 165 | |
| 166 metrics::MetricsService* AwMetricsServiceClientImpl::GetMetricsService() { | |
| 167 return metrics_service_.get(); | |
| 168 } | |
| 169 | |
| 170 // In Chrome, UMA and Breakpad are enabled/disabled together by the same | |
| 171 // checkbox and they share the same client ID (a.k.a. GUID). SetMetricsClientId | |
| 172 // is intended to provide the ID to Breakpad. In WebView, UMA and Breakpad are | |
| 173 // independent, so this is a no-op. | |
| 174 void AwMetricsServiceClientImpl::SetMetricsClientId( | |
| 175 const std::string& client_id) {} | |
| 176 | |
| 177 int32_t AwMetricsServiceClientImpl::GetProduct() { | |
| 178 return ::metrics::ChromeUserMetricsExtension::ANDROID_WEBVIEW; | |
| 179 } | |
| 180 | |
| 181 std::string AwMetricsServiceClientImpl::GetApplicationLocale() { | |
| 182 return base::i18n::GetConfiguredLocale(); | |
| 183 } | |
| 184 | |
| 185 bool AwMetricsServiceClientImpl::GetBrand(std::string* brand_code) { | |
| 186 // WebView doesn't use brand codes. | |
| 187 return false; | |
| 188 } | |
| 189 | |
| 190 metrics::SystemProfileProto::Channel AwMetricsServiceClientImpl::GetChannel() { | |
| 191 // "Channel" means stable, beta, etc. WebView doesn't have channel info yet. | |
| 192 // TODO(paulmiller) Update this once we have channel info. | |
| 193 return metrics::SystemProfileProto::CHANNEL_UNKNOWN; | |
| 194 } | |
| 195 | |
| 196 std::string AwMetricsServiceClientImpl::GetVersionString() { | |
| 197 return PRODUCT_VERSION; | |
| 198 } | |
| 199 | |
| 200 void AwMetricsServiceClientImpl::InitializeSystemProfileMetrics( | |
| 201 const base::Closure& done_callback) { | |
| 202 done_callback.Run(); | |
| 203 } | |
| 204 | |
| 205 void AwMetricsServiceClientImpl::CollectFinalMetricsForLog( | |
| 206 const base::Closure& done_callback) { | |
| 207 done_callback.Run(); | |
| 208 } | |
| 209 | |
| 210 std::unique_ptr<metrics::MetricsLogUploader> | |
| 211 AwMetricsServiceClientImpl::CreateUploader( | |
| 212 base::StringPiece server_url, | |
| 213 base::StringPiece mime_type, | |
| 214 metrics::MetricsLogUploader::MetricServiceType service_type, | |
| 215 const metrics::MetricsLogUploader::UploadCallback& on_upload_complete) { | |
| 216 // |server_url| and |mime_type| are unused because WebView uses the platform | |
| 217 // logging mechanism instead of the normal UMA server. | |
| 218 return std::unique_ptr<::metrics::MetricsLogUploader>( | |
| 219 new AwMetricsLogUploader(on_upload_complete)); | |
| 220 } | |
| 221 | |
| 222 base::TimeDelta AwMetricsServiceClientImpl::GetStandardUploadInterval() { | |
| 223 // The platform logging mechanism is responsible for upload frequency; this | |
| 224 // just specifies how frequently to provide logs to the platform. | |
| 225 return base::TimeDelta::FromMinutes(kUploadIntervalMinutes); | |
| 226 } | |
| 227 | |
| 228 AwMetricsServiceClientImpl::AwMetricsServiceClientImpl() | |
| 229 : is_enabled_(false), | |
| 230 pref_service_(nullptr), | |
| 231 request_context_(nullptr) {} | |
| 232 | |
| 233 AwMetricsServiceClientImpl::~AwMetricsServiceClientImpl() {} | |
| 234 | |
| 235 // static | |
| 236 void SetMetricsEnabled( | |
| 237 JNIEnv* env, | |
| 238 const base::android::JavaParamRef<jclass>& jcaller, | |
| 239 jboolean enabled) { | |
| 240 g_lazy_instance_.Pointer()->SetMetricsEnabled(enabled); | |
| 241 } | |
| 242 | |
| 243 bool RegisterAwMetricsServiceClient(JNIEnv* env) { | |
| 244 return RegisterNativesImpl(env); | |
| 245 } | |
| 246 | |
| 247 } // namespace android_webview | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2863233002:
[WebView] Move files from native to browser (Closed)
