Introduce AndroidMetricsProvider class.

BUG=374219
R=isherman@chromium.org

Review URL: https://codereview.chromium.org/294043008

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@272136 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 108 insertions, 65 deletions

diff --git a/chrome/browser/metrics/metrics_service_android.cc b/chrome/browser/metrics/android_metrics_provider.cc
index 6076842..f696b07 100644
--- a/chrome/browser/metrics/metrics_service_android.cc
+++ b/chrome/browser/metrics/android_metrics_provider.cc
@@ -2,15 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/browser/metrics/metrics_service.h"
+#include "chrome/browser/metrics/android_metrics_provider.h"
 
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/values.h"
-#include "chrome/browser/android/activity_type_ids.h"
-#include "chrome/browser/browser_process.h"
 #include "chrome/common/pref_names.h"
 
 namespace {
@@ -31,22 +29,29 @@ int GetActivityFlag(int type_id) {
 
 }  // namespace
 
-// static
-void MetricsService::RegisterPrefsAndroid(PrefRegistrySimple* registry) {
-  registry->RegisterIntegerPref(prefs::kStabilityForegroundActivityType,
-                                ActivityTypeIds::ACTIVITY_NONE);
-  registry->RegisterIntegerPref(prefs::kStabilityLaunchedActivityFlags, 0);
-  registry->RegisterListPref(prefs::kStabilityLaunchedActivityCounts);
-  registry->RegisterListPref(prefs::kStabilityCrashedActivityCounts);
+AndroidMetricsProvider::AndroidMetricsProvider(PrefService* local_state)
+    : local_state_(local_state) {
+  LogStabilityToPrefs();
+}
+
+AndroidMetricsProvider::~AndroidMetricsProvider() {
+}
+
+
+void AndroidMetricsProvider::ProvideStabilityMetrics(
+    metrics::SystemProfileProto_Stability* stability_proto) {
+  ConvertStabilityPrefsToHistograms();
 }
 
-void MetricsService::LogAndroidStabilityToPrefs(PrefService* pref) {
+void AndroidMetricsProvider::LogStabilityToPrefs() {
   // Track which Activities were launched by the user.
   // A 'launch' is defined as starting the Activity at least once during a
   // UMA session.  Multiple launches are counted only once since it is possible
   // for users to hop between Activities (e.g. entering and leaving Settings).
-  int launched = pref->GetInteger(prefs::kStabilityLaunchedActivityFlags);
-  ListPrefUpdate update_launches(pref, prefs::kStabilityLaunchedActivityCounts);
+  const int launched =
+      local_state_->GetInteger(prefs::kStabilityLaunchedActivityFlags);
+  ListPrefUpdate update_launches(local_state_,
+                                 prefs::kStabilityLaunchedActivityCounts);
   base::ListValue* launch_counts = update_launches.Get();
   for (int activity_type = ActivityTypeIds::ACTIVITY_NONE;
        activity_type < ActivityTypeIds::ACTIVITY_MAX_VALUE;
@@ -54,27 +59,30 @@ void MetricsService::LogAndroidStabilityToPrefs(PrefService* pref) {
     if (launched & GetActivityFlag(activity_type))
       IncrementListValue(launch_counts, activity_type);
   }
-  pref->SetInteger(prefs::kStabilityLaunchedActivityFlags, 0);
+  local_state_->SetInteger(prefs::kStabilityLaunchedActivityFlags, 0);
 
   // Track any Activities that were in the foreground when Chrome died.
   // These Activities failed to be recorded as leaving the foreground, so Chrome
   // couldn't have ended the UMA session cleanly.  Record them as crashing.
-  int foreground = pref->GetInteger(prefs::kStabilityForegroundActivityType);
+  const int foreground =
+      local_state_->GetInteger(prefs::kStabilityForegroundActivityType);
   if (foreground != ActivityTypeIds::ACTIVITY_NONE) {
-    ListPrefUpdate update_crashes(pref, prefs::kStabilityCrashedActivityCounts);
+    ListPrefUpdate update_crashes(local_state_,
+                                  prefs::kStabilityCrashedActivityCounts);
     base::ListValue* crash_counts = update_crashes.Get();
     IncrementListValue(crash_counts, foreground);
-    pref->SetInteger(prefs::kStabilityForegroundActivityType,
-                     ActivityTypeIds::ACTIVITY_NONE);
+    local_state_->SetInteger(prefs::kStabilityForegroundActivityType,
+                             ActivityTypeIds::ACTIVITY_NONE);
   }
 
-  pref->CommitPendingWrite();
+  local_state_->CommitPendingWrite();
 }
 
-void MetricsService::ConvertAndroidStabilityPrefsToHistograms(
-    PrefService* pref) {
-  ListPrefUpdate launch_updater(pref, prefs::kStabilityLaunchedActivityCounts);
-  ListPrefUpdate crash_updater(pref, prefs::kStabilityCrashedActivityCounts);
+void AndroidMetricsProvider::ConvertStabilityPrefsToHistograms() {
+  ListPrefUpdate launch_updater(local_state_,
+                                prefs::kStabilityLaunchedActivityCounts);
+  ListPrefUpdate crash_updater(local_state_,
+                               prefs::kStabilityCrashedActivityCounts);
 
   base::ListValue* launch_counts = launch_updater.Get();
   base::ListValue* crash_counts = crash_updater.Get();
@@ -106,25 +114,34 @@ void MetricsService::ConvertAndroidStabilityPrefsToHistograms(
   crash_counts->Clear();
 }
 
-void MetricsService::OnForegroundActivityChanged(PrefService* pref,
-                                                 ActivityTypeIds::Type type) {
-  DCHECK(type < ActivityTypeIds::ACTIVITY_MAX_VALUE);
+void AndroidMetricsProvider::OnForegroundActivityChanged(
+    ActivityTypeIds::Type type) {
+  DCHECK_LT(type, ActivityTypeIds::ACTIVITY_MAX_VALUE);
 
-  int activity_type = pref->GetInteger(prefs::kStabilityForegroundActivityType);
-  if (activity_type == type)
+  if (type == local_state_->GetInteger(prefs::kStabilityForegroundActivityType))
     return;
 
   // Record that the Activity is now in the foreground.
-  pref->SetInteger(prefs::kStabilityForegroundActivityType, type);
+  local_state_->SetInteger(prefs::kStabilityForegroundActivityType, type);
 
   // Record that the Activity was launched this sesaion.
   // The pref stores a set of flags ORed together, where each set flag
   // corresponds to a launched Activity type.
-  int launched = pref->GetInteger(prefs::kStabilityLaunchedActivityFlags);
+  int launched =
+      local_state_->GetInteger(prefs::kStabilityLaunchedActivityFlags);
   if (type != ActivityTypeIds::ACTIVITY_NONE) {
     launched |= GetActivityFlag(type);
-    pref->SetInteger(prefs::kStabilityLaunchedActivityFlags, launched);
+    local_state_->SetInteger(prefs::kStabilityLaunchedActivityFlags, launched);
   }
 
-  pref->CommitPendingWrite();
+  local_state_->CommitPendingWrite();
+}
+
+// static
+void AndroidMetricsProvider::RegisterPrefs(PrefRegistrySimple* registry) {
+  registry->RegisterIntegerPref(prefs::kStabilityForegroundActivityType,
+                                ActivityTypeIds::ACTIVITY_NONE);
+  registry->RegisterIntegerPref(prefs::kStabilityLaunchedActivityFlags, 0);
+  registry->RegisterListPref(prefs::kStabilityLaunchedActivityCounts);
+  registry->RegisterListPref(prefs::kStabilityCrashedActivityCounts);
 }
diff --git a/chrome/browser/metrics/android_metrics_provider.h b/chrome/browser/metrics/android_metrics_provider.h
new file mode 100644
index 0000000..8a00adc
--- /dev/null
+++ b/chrome/browser/metrics/android_metrics_provider.h
@@ -0,0 +1,46 @@
+// Copyright 2014 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.
+
+#ifndef CHROME_BROWSER_METRICS_ANDROID_METRICS_PROVIDER_H_
+#define CHROME_BROWSER_METRICS_ANDROID_METRICS_PROVIDER_H_
+
+#include "base/basictypes.h"
+#include "chrome/browser/android/activity_type_ids.h"
+#include "components/metrics/metrics_provider.h"
+
+class PrefService;
+class PrefRegistrySimple;
+
+// AndroidMetricsProvider provides Android-specific stability metrics.
+class AndroidMetricsProvider : public metrics::MetricsProvider {
+ public:
+  // Creates the AndroidMetricsProvider with the given |local_state|.
+  explicit AndroidMetricsProvider(PrefService* local_state);
+  virtual ~AndroidMetricsProvider();
+
+  // Called when the Activity that the user interacts with is swapped out.
+  // TODO(asvitkine): Expose a way for Android code to actually invoke this.
+  void OnForegroundActivityChanged(ActivityTypeIds::Type type);
+
+  // metrics::MetricsDataProvider:
+  virtual void ProvideStabilityMetrics(
+      metrics::SystemProfileProto_Stability* stability_proto) OVERRIDE;
+
+  // Registers local state prefs used by this class.
+  static void RegisterPrefs(PrefRegistrySimple* registry);
+
+ private:
+  // Called to log launch and crash stats to preferences.
+  void LogStabilityToPrefs();
+
+  // Converts crash stats stored in the preferences into histograms.
+  void ConvertStabilityPrefsToHistograms();
+
+  // Weak pointer to the local state prefs store.
+  PrefService* local_state_;
+
+  DISALLOW_COPY_AND_ASSIGN(AndroidMetricsProvider);
+};
+
+#endif  // CHROME_BROWSER_METRICS_ANDROID_METRICS_PROVIDER_H_
diff --git a/chrome/browser/metrics/metrics_service.cc b/chrome/browser/metrics/metrics_service.cc
index 23972d8..0dd1701 100644
--- a/chrome/browser/metrics/metrics_service.cc
+++ b/chrome/browser/metrics/metrics_service.cc
@@ -236,7 +236,10 @@
 #include "chrome/browser/metrics/google_update_metrics_provider_win.h"
 #endif
 
-#if !defined(OS_ANDROID)
+#if defined(OS_ANDROID)
+// TODO(asvitkine): Move this out of MetricsService.
+#include "chrome/browser/metrics/android_metrics_provider.h"
+#else
 #include "chrome/browser/service_process/service_process_control.h"
 #endif
 
@@ -455,7 +458,8 @@ void MetricsService::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterInt64Pref(prefs::kUninstallLastObservedRunTimeSec, 0);
 
 #if defined(OS_ANDROID)
-  RegisterPrefsAndroid(registry);
+  // TODO(asvitkine): Move this out of here.
+  AndroidMetricsProvider::RegisterPrefs(registry);
 #endif  // defined(OS_ANDROID)
 }
 
@@ -481,6 +485,13 @@ MetricsService::MetricsService(metrics::MetricsStateManager* state_manager,
   DCHECK(state_manager_);
   DCHECK(client_);
 
+#if defined(OS_ANDROID)
+  // TODO(asvitkine): Move this out of MetricsService.
+  RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(new AndroidMetricsProvider(
+          g_browser_process->local_state())));
+#endif  // defined(OS_ANDROID)
+
   // TODO(asvitkine): Move this out of MetricsService.
   RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(new OmniboxMetricsProvider));
@@ -828,10 +839,6 @@ void MetricsService::InitializeMetricsState() {
 
   session_id_ = pref->GetInteger(prefs::kMetricsSessionID);
 
-#if defined(OS_ANDROID)
-  LogAndroidStabilityToPrefs(pref);
-#endif  // defined(OS_ANDROID)
-
   if (!pref->GetBoolean(prefs::kStabilityExitedCleanly)) {
     IncrementPrefValue(prefs::kStabilityCrashCount);
     // Reset flag, and wait until we call LogNeedForCleanShutdown() before
@@ -1387,11 +1394,7 @@ void MetricsService::PrepareInitialStabilityLog() {
       static_cast<MetricsLog*>(log_manager_.current_log());
   current_log->RecordStabilityMetrics(metrics_providers_.get(),
                                       base::TimeDelta(), base::TimeDelta());
-
-#if defined(OS_ANDROID)
-  ConvertAndroidStabilityPrefsToHistograms(pref);
   RecordCurrentStabilityHistograms();
-#endif  // defined(OS_ANDROID)
 
   // Note: RecordGeneralMetrics() intentionally not called since this log is for
   //       stability stats from a previous session only.
@@ -1430,10 +1433,6 @@ void MetricsService::PrepareInitialMetricsLog() {
       static_cast<MetricsLog*>(log_manager_.current_log());
   current_log->RecordStabilityMetrics(metrics_providers_.get(),
                                       base::TimeDelta(), base::TimeDelta());
-
-#if defined(OS_ANDROID)
-  ConvertAndroidStabilityPrefsToHistograms(pref);
-#endif  // defined(OS_ANDROID)
   RecordCurrentHistograms();
 
   current_log->RecordGeneralMetrics(metrics_providers_.get());
diff --git a/chrome/browser/metrics/metrics_service.h b/chrome/browser/metrics/metrics_service.h
index 00e12dc..97dfcc3 100644
--- a/chrome/browser/metrics/metrics_service.h
+++ b/chrome/browser/metrics/metrics_service.h
@@ -35,10 +35,6 @@
 #include "content/public/browser/user_metrics.h"
 #include "net/url_request/url_fetcher_delegate.h"
 
-#if defined(OS_ANDROID)
-#include "chrome/browser/android/activity_type_ids.h"
-#endif
-
 class ChromeBrowserMetricsServiceObserver;
 class GoogleUpdateMetricsProviderWin;
 class MetricsReportingScheduler;
@@ -188,9 +184,6 @@ class MetricsService
   // At startup, prefs needs to be called with a list of all the pref names and
   // types we'll be using.
   static void RegisterPrefs(PrefRegistrySimple* registry);
-#if defined(OS_ANDROID)
-  static void RegisterPrefsAndroid(PrefRegistrySimple* registry);
-#endif  // defined(OS_ANDROID)
 
   // Set up notifications which indicate that a user is performing work. This is
   // useful to allow some features to sleep, until the machine becomes active,
@@ -223,18 +216,6 @@ class MetricsService
   // that session end was successful.
   void RecordCompletedSessionEnd();
 
-#if defined(OS_ANDROID)
-  // Called to log launch and crash stats to preferences.
-  void LogAndroidStabilityToPrefs(PrefService* pref);
-
-  // Converts crash stats stored in the preferences into histograms.
-  void ConvertAndroidStabilityPrefsToHistograms(PrefService* pref);
-
-  // Called when the Activity that the user interacts with is swapped out.
-  void OnForegroundActivityChanged(PrefService* pref,
-                                   ActivityTypeIds::Type type);
-#endif  // defined(OS_ANDROID)
-
 #if defined(OS_ANDROID) || defined(OS_IOS)
   // Called when the application is going into background mode.
   void OnAppEnterBackground();