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 namespace { |
| 29 |
| 30 // BlimpMetricsServiceClient provides an implementation of MetricsServiceClient |
| 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 |