Revert of Add tests for Chrome Stability Metrics.

chrome/browser/metrics/chrome_stability_metrics_provider.cc

 // 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.
 
 #include "chrome/browser/metrics/chrome_stability_metrics_provider.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/pref_names.h"
 #include "components/metrics/proto/system_profile.pb.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 
@@ skipping 10 matching lines @@
 #include "chrome/installer/util/install_util.h"
 #include "components/browser_watcher/crash_reporting_metrics_win.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/memory/system_memory_stats_recorder.h"
 #endif
 
 namespace {
 
+void IncrementPrefValue(const char* path) {
+  PrefService* pref = g_browser_process->local_state();
+  DCHECK(pref);
+  int value = pref->GetInteger(path);
+  pref->SetInteger(path, value + 1);
+}
+
+void IncrementLongPrefsValue(const char* path) {
+  PrefService* pref = g_browser_process->local_state();
+  DCHECK(pref);
+  int64 value = pref->GetInt64(path);
+  pref->SetInt64(path, value + 1);
+}
+
 // Converts an exit code into something that can be inserted into our
 // histograms (which expect non-negative numbers less than MAX_INT).
 int MapCrashExitCodeForHistogram(int exit_code) {
 #if defined(OS_WIN)
   // Since |abs(STATUS_GUARD_PAGE_VIOLATION) == MAX_INT| it causes problems in
   // histograms.cc. Solve this by remapping it to a smaller value, which
   // hopefully doesn't conflict with other codes.
   if (exit_code == STATUS_GUARD_PAGE_VIOLATION)
     return 0x1FCF7EC3;  // Randomly picked number.
 #endif
@@ skipping 44 matching lines @@
 }
 #endif  // defined(OS_WIN)
 
 void RecordChildKills(bool was_extension_process) {
   UMA_HISTOGRAM_PERCENTAGE("BrowserRenderProcessHost.ChildKills",
                            was_extension_process ? 2 : 1);
 }
 
 }  // namespace
 
-ChromeStabilityMetricsProvider::ChromeStabilityMetricsProvider(
-    PrefService* local_state)
-    : local_state_(local_state) {
-  DCHECK(local_state_);
+ChromeStabilityMetricsProvider::ChromeStabilityMetricsProvider() {
   BrowserChildProcessObserver::Add(this);
 }
 
 ChromeStabilityMetricsProvider::~ChromeStabilityMetricsProvider() {
   BrowserChildProcessObserver::Remove(this);
 }
 
 void ChromeStabilityMetricsProvider::OnRecordingEnabled() {
   registrar_.Add(this,
                  content::NOTIFICATION_LOAD_START,
                  content::NotificationService::AllSources());
   registrar_.Add(this,
                  content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
                  content::NotificationService::AllSources());
   registrar_.Add(this,
                  content::NOTIFICATION_RENDER_WIDGET_HOST_HANG,
                  content::NotificationService::AllSources());
 }
 
 void ChromeStabilityMetricsProvider::OnRecordingDisabled() {
   registrar_.RemoveAll();
 }
 
 void ChromeStabilityMetricsProvider::ProvideStabilityMetrics(
     metrics::SystemProfileProto* system_profile_proto) {
+  PrefService* pref = g_browser_process->local_state();
   metrics::SystemProfileProto_Stability* stability_proto =
       system_profile_proto->mutable_stability();
 
-  int count = local_state_->GetInteger(prefs::kStabilityPageLoadCount);
+  int count = pref->GetInteger(prefs::kStabilityPageLoadCount);
   if (count) {
     stability_proto->set_page_load_count(count);
-    local_state_->SetInteger(prefs::kStabilityPageLoadCount, 0);
+    pref->SetInteger(prefs::kStabilityPageLoadCount, 0);
   }
 
-  count = local_state_->GetInteger(prefs::kStabilityChildProcessCrashCount);
+  count = pref->GetInteger(prefs::kStabilityChildProcessCrashCount);
   if (count) {
     stability_proto->set_child_process_crash_count(count);
-    local_state_->SetInteger(prefs::kStabilityChildProcessCrashCount, 0);
+    pref->SetInteger(prefs::kStabilityChildProcessCrashCount, 0);
   }
 
-  count = local_state_->GetInteger(prefs::kStabilityRendererCrashCount);
+  count = pref->GetInteger(prefs::kStabilityRendererCrashCount);
   if (count) {
     stability_proto->set_renderer_crash_count(count);
-    local_state_->SetInteger(prefs::kStabilityRendererCrashCount, 0);
+    pref->SetInteger(prefs::kStabilityRendererCrashCount, 0);
   }
 
-  count =
-      local_state_->GetInteger(prefs::kStabilityExtensionRendererCrashCount);
+  count = pref->GetInteger(prefs::kStabilityExtensionRendererCrashCount);
   if (count) {
     stability_proto->set_extension_renderer_crash_count(count);
-    local_state_->SetInteger(prefs::kStabilityExtensionRendererCrashCount, 0);
+    pref->SetInteger(prefs::kStabilityExtensionRendererCrashCount, 0);
   }
 
-  count = local_state_->GetInteger(prefs::kStabilityRendererHangCount);
+  count = pref->GetInteger(prefs::kStabilityRendererHangCount);
   if (count) {
     stability_proto->set_renderer_hang_count(count);
-    local_state_->SetInteger(prefs::kStabilityRendererHangCount, 0);
+    pref->SetInteger(prefs::kStabilityRendererHangCount, 0);
   }
 
 #if defined(OS_WIN)
   CountBrowserCrashDumpAttempts();
 #endif  // defined(OS_WIN)
 }
 
 void ChromeStabilityMetricsProvider::ClearSavedStabilityMetrics() {
+  PrefService* local_state = g_browser_process->local_state();
+
   // Clear all the prefs used in this class in UMA reports (which doesn't
   // include |kUninstallMetricsPageLoadCount| as it's not sent up by UMA).
-  local_state_->SetInteger(prefs::kStabilityChildProcessCrashCount, 0);
-  local_state_->SetInteger(prefs::kStabilityExtensionRendererCrashCount, 0);
-  local_state_->SetInteger(prefs::kStabilityPageLoadCount, 0);
-  local_state_->SetInteger(prefs::kStabilityRendererCrashCount, 0);
-  local_state_->SetInteger(prefs::kStabilityRendererHangCount, 0);
+  local_state->SetInteger(prefs::kStabilityChildProcessCrashCount, 0);
+  local_state->SetInteger(prefs::kStabilityExtensionRendererCrashCount, 0);
+  local_state->SetInteger(prefs::kStabilityPageLoadCount, 0);
+  local_state->SetInteger(prefs::kStabilityRendererCrashCount, 0);
+  local_state->SetInteger(prefs::kStabilityRendererHangCount, 0);
 }
 
 // static
 void ChromeStabilityMetricsProvider::RegisterPrefs(
     PrefRegistrySimple* registry) {
   registry->RegisterIntegerPref(prefs::kStabilityChildProcessCrashCount, 0);
   registry->RegisterIntegerPref(prefs::kStabilityExtensionRendererCrashCount,
                                 0);
   registry->RegisterIntegerPref(prefs::kStabilityPageLoadCount, 0);
   registry->RegisterIntegerPref(prefs::kStabilityRendererCrashCount, 0);
@@ skipping 98 matching lines @@
         was_extension_process
             ? memory::RECORD_MEMORY_STATS_EXTENSIONS_OOM_KILLED
             : memory::RECORD_MEMORY_STATS_CONTENTS_OOM_KILLED);
 #endif
   } else if (status == base::TERMINATION_STATUS_STILL_RUNNING) {
     UMA_HISTOGRAM_PERCENTAGE("BrowserRenderProcessHost.DisconnectedAlive",
                              was_extension_process ? 2 : 1);
   }
 }
 
-void ChromeStabilityMetricsProvider::IncrementPrefValue(const char* path) {
-  int value = local_state_->GetInteger(path);
-  local_state_->SetInteger(path, value + 1);
-}
-
-void ChromeStabilityMetricsProvider::IncrementLongPrefsValue(const char* path) {
-  int64 value = local_state_->GetInt64(path);
-  local_state_->SetInt64(path, value + 1);
-}
-
 void ChromeStabilityMetricsProvider::LogRendererHang() {
   IncrementPrefValue(prefs::kStabilityRendererHangCount);
 }