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 // How often after initial logging metrics results should be uploaded to the |
| 31 // metrics service. |
| 32 const int kStandardUploadIntervalMinutes = 30; |
| 33 |
| 34 // Returns if the MetricsService should be recording metrics information for |
| 35 // the client. Always true. |
| 36 // This callback is required by MetricsStateManager::Create. |
| 37 bool IsReportingEnabled() { |
| 38 return true; |
| 39 } |
| 40 |
| 41 // Store/LoadClientInfo allows Windows Chrome to back up ClientInfo. |
| 42 // Both are no-ops for Blimp. |
| 43 // These callbacks are required by MetricsStateManager::Create. |
| 44 void StoreClientInfo(const metrics::ClientInfo& client_info) {} |
| 45 |
| 46 std::unique_ptr<metrics::ClientInfo> LoadClientInfo() { |
| 47 return nullptr; |
| 48 } |
| 49 |
| 50 } // namespace |
| 51 |
| 52 BlimpMetricsServiceClient::BlimpMetricsServiceClient( |
| 53 PrefService* pref_service, |
| 54 scoped_refptr<net::URLRequestContextGetter> request_context_getter) { |
| 55 request_context_getter_ = request_context_getter; |
| 56 |
| 57 metrics_state_manager_ = metrics::MetricsStateManager::Create( |
| 58 pref_service, base::Bind(&IsReportingEnabled), |
| 59 base::Bind(&StoreClientInfo), base::Bind(&LoadClientInfo)); |
| 60 |
| 61 // Metrics state manager created while other class instances exist. |
| 62 // Sign of multiple initializations. |
| 63 DCHECK(metrics_state_manager_); |
| 64 |
| 65 metrics_service_.reset(new metrics::MetricsService( |
| 66 metrics_state_manager_.get(), this, pref_service)); |
| 67 metrics_service_->RegisterMetricsProvider( |
| 68 base::WrapUnique<metrics::MetricsProvider>( |
| 69 new metrics::NetworkMetricsProvider( |
| 70 content::BrowserThread::GetBlockingPool()))); |
| 71 metrics_service_->RegisterMetricsProvider( |
| 72 base::WrapUnique<metrics::MetricsProvider>( |
| 73 new metrics::GPUMetricsProvider)); |
| 74 metrics_service_->RegisterMetricsProvider( |
| 75 base::WrapUnique<metrics::MetricsProvider>( |
| 76 new metrics::ScreenInfoMetricsProvider)); |
| 77 metrics_service_->RegisterMetricsProvider( |
| 78 base::WrapUnique<metrics::MetricsProvider>( |
| 79 new metrics::ProfilerMetricsProvider())); |
| 80 metrics_service_->RegisterMetricsProvider( |
| 81 base::WrapUnique<metrics::MetricsProvider>( |
| 82 new metrics::CallStackProfileMetricsProvider)); |
| 83 metrics_service_->InitializeMetricsRecordingState(); |
| 84 if (IsReportingEnabled()) |
| 85 metrics_service_->Start(); |
| 86 } |
| 87 |
| 88 BlimpMetricsServiceClient::~BlimpMetricsServiceClient() {} |
| 89 |
| 90 metrics::MetricsService* BlimpMetricsServiceClient::GetMetricsService() { |
| 91 return metrics_service_.get(); |
| 92 } |
| 93 |
| 94 // In Chrome, UMA and Breakpad are enabled/disabled together by the same |
| 95 // checkbox and they share the same client ID (a.k.a. GUID). |
| 96 // This is not required by Blimp, so these are no-ops. |
| 97 void BlimpMetricsServiceClient::SetMetricsClientId( |
| 98 const std::string& client_id) {} |
| 99 |
| 100 // Recording can not be disabled in Blimp, so this function is a no-op. |
| 101 void BlimpMetricsServiceClient::OnRecordingDisabled() {} |
| 102 |
| 103 bool BlimpMetricsServiceClient::IsOffTheRecordSessionActive() { |
| 104 // Blimp does not have incognito mode. |
| 105 return false; |
| 106 } |
| 107 |
| 108 int32_t BlimpMetricsServiceClient::GetProduct() { |
| 109 // Indicates product family (e.g. Chrome v Android Webview), not reported |
| 110 // platform (e.g. Chrome_Linux, Chrome_Mac). |
| 111 return metrics::ChromeUserMetricsExtension::CHROME; |
| 112 } |
| 113 |
| 114 std::string BlimpMetricsServiceClient::GetApplicationLocale() { |
| 115 return base::i18n::GetConfiguredLocale(); |
| 116 } |
| 117 |
| 118 bool BlimpMetricsServiceClient::GetBrand(std::string* brand_code) { |
| 119 // Blimp doesn't use brand codes. |
| 120 return false; |
| 121 } |
| 122 |
| 123 metrics::SystemProfileProto::Channel BlimpMetricsServiceClient::GetChannel() { |
| 124 // Blimp engine does not have channel info yet. |
| 125 return metrics::SystemProfileProto::CHANNEL_UNKNOWN; |
| 126 } |
| 127 |
| 128 std::string BlimpMetricsServiceClient::GetVersionString() { |
| 129 return version_info::GetVersionNumber(); |
| 130 } |
| 131 |
| 132 void BlimpMetricsServiceClient::OnLogUploadComplete() {} |
| 133 |
| 134 void BlimpMetricsServiceClient::InitializeSystemProfileMetrics( |
| 135 const base::Closure& done_callback) { |
| 136 // Blimp requires no additional work to InitializeSystemProfileMetrics |
| 137 // and should proceed to the next call in the chain. |
| 138 done_callback.Run(); |
| 139 } |
| 140 |
| 141 void BlimpMetricsServiceClient::CollectFinalMetricsForLog( |
| 142 const base::Closure& done_callback) { |
| 143 // Blimp requires no additional work to CollectFinalMetricsForLog |
| 144 // and should proceed to the next call in the chain |
| 145 done_callback.Run(); |
| 146 } |
| 147 |
| 148 std::unique_ptr<metrics::MetricsLogUploader> |
| 149 BlimpMetricsServiceClient::CreateUploader( |
| 150 const base::Callback<void(int)>& on_upload_complete) { |
| 151 return base::WrapUnique<metrics::MetricsLogUploader>( |
| 152 new metrics::NetMetricsLogUploader( |
| 153 request_context_getter_.get(), metrics::kDefaultMetricsServerUrl, |
| 154 metrics::kDefaultMetricsMimeType, on_upload_complete)); |
| 155 } |
| 156 |
| 157 base::TimeDelta BlimpMetricsServiceClient::GetStandardUploadInterval() { |
| 158 return base::TimeDelta::FromMinutes(kStandardUploadIntervalMinutes); |
| 159 } |
| 160 |
| 161 metrics::MetricsServiceClient::EnableMetricsDefault |
| 162 BlimpMetricsServiceClient::GetDefaultOptIn() { |
| 163 return OPT_IN; |
| 164 } |
| 165 |
| 166 } // namespace engine |
| 167 } // namespace blimp |
OLD | NEW |