Index: blimp/engine/app/blimp_metrics_service_client.cc |
diff --git a/blimp/engine/app/blimp_metrics_service_client.cc b/blimp/engine/app/blimp_metrics_service_client.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..be50474df633ec0de18c6fe16706775fd6e33492 |
--- /dev/null |
+++ b/blimp/engine/app/blimp_metrics_service_client.cc |
@@ -0,0 +1,238 @@ |
+// Copyright 2016 The Chromium Authors. All rights reserved. |
+// Use of this source code is governed by a BSD-style license that can be |
+// found in the LICENSE file. |
+ |
+#include "blimp/engine/app/blimp_metrics_service_client.h" |
+ |
+#include "base/bind.h" |
+#include "base/i18n/rtl.h" |
+#include "base/lazy_instance.h" |
+#include "base/memory/ptr_util.h" |
+#include "base/memory/ref_counted.h" |
+#include "components/metrics/call_stack_profile_metrics_provider.h" |
+#include "components/metrics/gpu/gpu_metrics_provider.h" |
+#include "components/metrics/metrics_service.h" |
+#include "components/metrics/metrics_service_client.h" |
+#include "components/metrics/metrics_state_manager.h" |
+#include "components/metrics/net/net_metrics_log_uploader.h" |
+#include "components/metrics/profiler/profiler_metrics_provider.h" |
+#include "components/metrics/ui/screen_info_metrics_provider.h" |
+#include "components/metrics/url_constants.h" |
+#include "components/prefs/pref_service.h" |
+#include "content/public/browser/browser_thread.h" |
+#include "net/url_request/url_request_context_getter.h" |
+ |
+namespace blimp { |
+namespace engine { |
+ |
+// BlimpMetricsServiceClient provides a singleton implementation of |
+// MetricsServiceClient tailored for the Blimp engine. |
+// Metrics are always turned on. |
+class BlimpMetricsServiceClient : public metrics::MetricsServiceClient { |
Wez
2016/05/01 00:12:58
This should be tucked away in an anonymous namespa
|
+ public: |
+ BlimpMetricsServiceClient(); |
+ ~BlimpMetricsServiceClient() override; |
+ |
+ // The request_context_getter is a system request context that must remain |
+ // valid for the client lifetime. |
Wez
2016/05/01 00:12:58
nit: Since it's ref-counted is there any way it mi
|
+ void Initialize( |
+ std::unique_ptr<PrefService> pref_service, |
+ scoped_refptr<net::URLRequestContextGetter> request_context_getter); |
+ void Finalize(); |
+ |
+ // metrics::MetricsServiceClient implementation. |
+ metrics::MetricsService* GetMetricsService() override; |
+ void SetMetricsClientId(const std::string& client_id) override; |
+ void OnRecordingDisabled() override; |
+ bool IsOffTheRecordSessionActive() override; |
+ int32_t GetProduct() override; |
+ std::string GetApplicationLocale() override; |
+ bool GetBrand(std::string* brand_code) override; |
+ metrics::SystemProfileProto::Channel GetChannel() override; |
+ std::string GetVersionString() override; |
+ void OnLogUploadComplete() override; |
+ void InitializeSystemProfileMetrics( |
+ const base::Closure& done_callback) override; |
+ void CollectFinalMetricsForLog(const base::Closure& done_callback) override; |
+ std::unique_ptr<metrics::MetricsLogUploader> CreateUploader( |
+ const base::Callback<void(int)>& on_upload_complete) override; |
+ base::TimeDelta GetStandardUploadInterval() override; |
+ metrics::MetricsServiceClient::EnableMetricsDefault GetDefaultOptIn() |
+ override; |
+ |
+ private: |
+ // Used by NetMetricsLogUploader to create log-upload requests. |
+ scoped_refptr<net::URLRequestContextGetter> request_context_getter_; |
+ std::unique_ptr<metrics::MetricsStateManager> metrics_state_manager_; |
+ std::unique_ptr<metrics::MetricsService> metrics_service_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(BlimpMetricsServiceClient); |
+}; |
+ |
+namespace { |
+ |
+// How often after initial logging metrics results should be uploaded to the |
Wez
2016/05/01 00:12:58
nit: Not sure what this means; are you just saying
|
+// metrics service. |
+const int kStandardUploadIntervalMinutes = 30; |
+ |
+base::LazyInstance<BlimpMetricsServiceClient>::Leaky g_lazy_instance_; |
Wez
2016/05/01 00:12:58
Does this actually need to be a lazy instance? We
|
+ |
+// Returns if the MetricsService should be recording metrics information for |
Wez
2016/05/01 00:12:59
nit: if -> whether
|
+// the client. |
+// This callback required by MetricsStateManager::Create. |
Wez
2016/05/01 00:12:58
nit: is required
|
+bool IsReportingEnabled() { |
+ return true; |
+} |
+ |
+// Store/LoadClientInfo allows Windows Chrome to back up ClientInfo. |
+// Both are no-ops for Blimp. |
+// These callbacks are required by MetricsStateManager::Create. |
+void StoreClientInfo(const metrics::ClientInfo& client_info) {} |
+ |
+std::unique_ptr<metrics::ClientInfo> LoadClientInfo() { |
+ return nullptr; |
+} |
+ |
+} // namespace |
+ |
+void BlimpMetricsServiceClient::Initialize( |
+ std::unique_ptr<PrefService> pref_service, |
+ scoped_refptr<net::URLRequestContextGetter> request_context_getter) { |
+ request_context_getter_ = request_context_getter; |
+ |
+ metrics_state_manager_ = metrics::MetricsStateManager::Create( |
+ pref_service.get(), base::Bind(&IsReportingEnabled), |
+ base::Bind(&StoreClientInfo), base::Bind(&LoadClientInfo)); |
+ |
+ metrics_service_.reset(new metrics::MetricsService( |
+ metrics_state_manager_.get(), this, pref_service.get())); |
+ |
+ metrics_service_->RegisterMetricsProvider( |
+ base::WrapUnique<metrics::MetricsProvider>( |
+ new metrics::NetworkMetricsProvider( |
+ content::BrowserThread::GetBlockingPool()))); |
+ |
+ metrics_service_->RegisterMetricsProvider( |
+ base::WrapUnique<metrics::MetricsProvider>( |
+ new metrics::GPUMetricsProvider)); |
+ |
+ metrics_service_->RegisterMetricsProvider( |
+ base::WrapUnique<metrics::MetricsProvider>( |
+ new metrics::ScreenInfoMetricsProvider)); |
+ |
+ metrics_service_->RegisterMetricsProvider( |
+ base::WrapUnique<metrics::MetricsProvider>( |
+ new metrics::ProfilerMetricsProvider())); |
+ |
+ metrics_service_->RegisterMetricsProvider( |
+ base::WrapUnique<metrics::MetricsProvider>( |
+ new metrics::CallStackProfileMetricsProvider)); |
+ |
+ metrics_service_->InitializeMetricsRecordingState(); |
+ |
+ if (IsReportingEnabled()) |
+ metrics_service_->Start(); |
+} |
+ |
+void BlimpMetricsServiceClient::Finalize() { |
+ metrics_service_->Stop(); |
+} |
+ |
+metrics::MetricsService* BlimpMetricsServiceClient::GetMetricsService() { |
+ return metrics_service_.get(); |
+} |
+ |
+// In Chrome, UMA and Breakpad are enabled/disabled together by the same |
+// checkbox and they share the same client ID (a.k.a. GUID). |
+// This is not required by Blimp, so these are no-ops. |
Wez
2016/05/01 00:12:58
nit: I think it's sufficient to say this is not re
|
+void BlimpMetricsServiceClient::SetMetricsClientId( |
+ const std::string& client_id) {} |
+ |
+// Recording can not be disabled in Blimp, so this function is a no-op. |
Wez
2016/05/01 00:12:58
nit: See above re :...so this is a no-op"
|
+void BlimpMetricsServiceClient::OnRecordingDisabled() {} |
+ |
+bool BlimpMetricsServiceClient::IsOffTheRecordSessionActive() { |
+ // Blimp does not have incognito mode. |
Wez
2016/05/01 00:12:59
nit: Move this comment outside the function much a
|
+ return false; |
+} |
+ |
+int32_t BlimpMetricsServiceClient::GetProduct() { |
+ // Indicates product family (e.g. Chrome v Android Webview), not reported |
+ // platform (e.g. Chrome_Linux, Chrome_Mac). |
+ return metrics::ChromeUserMetricsExtension::CHROME; |
+} |
+ |
+std::string BlimpMetricsServiceClient::GetApplicationLocale() { |
+ return base::i18n::GetConfiguredLocale(); |
+} |
+ |
+bool BlimpMetricsServiceClient::GetBrand(std::string* brand_code) { |
+ // Blimp doesn't use brand codes. |
+ return false; |
+} |
+ |
+metrics::SystemProfileProto::Channel BlimpMetricsServiceClient::GetChannel() { |
+ // Blimp engine does not have channel info yet. |
+ return metrics::SystemProfileProto::CHANNEL_UNKNOWN; |
+} |
+ |
+std::string BlimpMetricsServiceClient::GetVersionString() { |
+ // TODO(jessicag): Add in a meaningful version string. |
Wez
2016/05/01 00:12:58
I have a CL in-progress to add version stuff, so i
|
+ return std::string(); |
+} |
+ |
+void BlimpMetricsServiceClient::OnLogUploadComplete() {} |
+ |
+void BlimpMetricsServiceClient::InitializeSystemProfileMetrics( |
+ const base::Closure& done_callback) { |
+ // Blimp requires no additional work to InitializeSystemProfileMetrics |
+ // and should proceed to the next call in the chain. |
+ done_callback.Run(); |
+} |
+ |
+void BlimpMetricsServiceClient::CollectFinalMetricsForLog( |
+ const base::Closure& done_callback) { |
+ // Blimp requires no additional work to CollectFinalMetricsForLog |
+ // and should proceed to the next call in the chain |
+ done_callback.Run(); |
+} |
+ |
+std::unique_ptr<metrics::MetricsLogUploader> |
+BlimpMetricsServiceClient::CreateUploader( |
+ const base::Callback<void(int)>& on_upload_complete) { |
+ return base::WrapUnique<metrics::MetricsLogUploader>( |
+ new metrics::NetMetricsLogUploader( |
+ request_context_getter_.get(), metrics::kDefaultMetricsServerUrl, |
+ metrics::kDefaultMetricsMimeType, on_upload_complete)); |
+} |
+ |
+base::TimeDelta BlimpMetricsServiceClient::GetStandardUploadInterval() { |
+ return base::TimeDelta::FromMinutes(kStandardUploadIntervalMinutes); |
+} |
+ |
+metrics::MetricsServiceClient::EnableMetricsDefault |
+BlimpMetricsServiceClient::GetDefaultOptIn() { |
+ return OPT_IN; |
+} |
+ |
+BlimpMetricsServiceClient::BlimpMetricsServiceClient() {} |
+ |
+BlimpMetricsServiceClient::~BlimpMetricsServiceClient() {} |
+ |
+BlimpMetricsServiceClient* GetBlimpMetricsServiceClientInstance() { |
Wez
2016/05/01 00:12:58
This should be in an anonymous namespace; basicall
|
+ return g_lazy_instance_.Pointer(); |
+} |
+ |
+void InitializeBlimpMetrics( |
+ std::unique_ptr<PrefService> pref_service, |
+ scoped_refptr<net::URLRequestContextGetter> request_context_getter) { |
+ GetBlimpMetricsServiceClientInstance()->Initialize(std::move(pref_service), |
+ request_context_getter); |
+} |
+ |
+void FinalizeBlimpMetrics() { |
+ GetBlimpMetricsServiceClientInstance()->Finalize(); |
Wez
2016/05/01 00:12:58
Can you clear the lazy-instance here, in which cas
|
+} |
+ |
+} // namespace engine |
+} // namespace blimp |