Create and integrate a metrics service client into Blimp engine.

blimp/engine/app/blimp_metrics_service_client.cc

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..c69ac044dbff6680ae07ff32b26e24baa79853f6
--- /dev/null
+++ b/blimp/engine/app/blimp_metrics_service_client.cc
@@ -0,0 +1,171 @@
+// 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 "components/version_info/version_info.h"
+#include "content/public/browser/browser_thread.h"
+#include "net/url_request/url_request_context_getter.h"
+
+namespace blimp {
+namespace engine {
+namespace {
+// How often after initial logging metrics results should be uploaded to the

[Kevin M, 2016/05/11 17:08:42]

nit: add whitespace above comment

[Jess, 2016/05/11 20:17:29]

Done.

+// metrics service.
+const int kStandardUploadIntervalMinutes = 30;

[Kevin M, 2016/05/11 17:08:42]

This seems quite long? Would this mean that we miss out on metrics telemetry
from short lived sessions with Blimp?

Since this is happening on the engine side, aren't we able to increase the
frequency without any battery/CPU cost to the user?

[Jess, 2016/05/11 20:17:29]

This number is just taken from an existing use case.  I took a brief look at
updating it, but it became clear it we don't have the information yet to make
all that meaningful a selection.

Created http://crbug/611099 for tracking.

+
+// Returns if the MetricsService should be recording metrics information for

[Kevin M, 2016/05/11 17:08:42]

nit: returns true

[Jess, 2016/05/11 20:17:30]

Added note, but left longer explanation since the always true behavior is
temporary.

+// the client.
+// This callback is required by MetricsStateManager::Create.
+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
+
+BlimpMetricsServiceClient::BlimpMetricsServiceClient(
+    PrefService* pref_service,
+    scoped_refptr<net::URLRequestContextGetter> request_context_getter) {
+  request_context_getter_ = request_context_getter;
+
+  metrics_state_manager_ = metrics::MetricsStateManager::Create(
+      pref_service, base::Bind(&IsReportingEnabled),
+      base::Bind(&StoreClientInfo), base::Bind(&LoadClientInfo));
+
+  // Metrics state manager created while other class instances exist.
+  // Sign of multiple initializations.
+  DCHECK(metrics_state_manager_);
+
+  metrics_service_.reset(new metrics::MetricsService(
+      metrics_state_manager_.get(), this, pref_service));
+

[Kevin M, 2016/05/11 17:08:42]

nit: consider clumping all metrics_service_ creation/initialization into one
contiguous block

[Jess, 2016/05/11 20:17:30]

Done.

+  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();
+}
+
+BlimpMetricsServiceClient::~BlimpMetricsServiceClient() {
+  metrics_service_->Stop();

[Kevin M, 2016/05/11 17:08:42]

This isn't necessary; metrics_service_ stops itself on destruction

[Jess, 2016/05/11 20:17:29]

Done.

+}
+
+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.
+void BlimpMetricsServiceClient::SetMetricsClientId(
+    const std::string& client_id) {}
+
+// Recording can not be disabled in Blimp, so this function is a no-op.
+void BlimpMetricsServiceClient::OnRecordingDisabled() {}
+
+bool BlimpMetricsServiceClient::IsOffTheRecordSessionActive() {
+  // Blimp does not have incognito mode.
+  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() {
+  return version_info::GetVersionNumber();
+}
+
+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;
+}
+
+}  // namespace engine
+}  // namespace blimp