Add new termination status for failed launch

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"
@@ skipping 23 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 {
 
+enum RendererType {
+  RENDERER_TYPE_RENDERER,
+  RENDERER_TYPE_EXTENSION,
+  // NOTE: Add new action types only immediately above this line. Also,
+  // make sure the enum list in tools/metrics/histograms/histograms.xml is
+  // updated with any change in here.
+  RENDERER_TYPE_COUNT
+};
+
 // 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 37 matching lines @@
       outcome = OUTCOME_FAILURE;
     }
 
     UMA_STABILITY_HISTOGRAM_ENUMERATION(
         "CrashReport.BreakpadDumpWithoutCrashOutcome", outcome,
         OUTCOME_MAX_VALUE);
   }
 }
 #endif  // defined(OS_WIN)
 
-void RecordChildKills(bool was_extension_process) {
-  UMA_HISTOGRAM_PERCENTAGE("BrowserRenderProcessHost.ChildKills",
-                           was_extension_process ? 2 : 1);
+void RecordChildKills(int histogram_type) {
+  UMA_HISTOGRAM_ENUMERATION("BrowserRenderProcessHost.ChildKills",
+                            histogram_type, RENDERER_TYPE_COUNT);
 }
 
 }  // namespace
 
 ChromeStabilityMetricsProvider::ChromeStabilityMetricsProvider(
     PrefService* local_state)
     : local_state_(local_state) {
   DCHECK(local_state_);
   BrowserChildProcessObserver::Add(this);
 }
@@ skipping 137 matching lines @@
   IncrementPrefValue(prefs::kStabilityPageLoadCount);
   IncrementLongPrefsValue(prefs::kUninstallMetricsPageLoadCount);
   // We need to save the prefs, as page load count is a critical stat, and it
   // might be lost due to a crash :-(.
 }
 
 void ChromeStabilityMetricsProvider::LogRendererCrash(
     content::RenderProcessHost* host,
     base::TerminationStatus status,
     int exit_code) {
+  int histogram_type = RENDERER_TYPE_RENDERER;
   bool was_extension_process = false;
 #if defined(ENABLE_EXTENSIONS)
-  was_extension_process =
-      extensions::ProcessMap::Get(host->GetBrowserContext())->Contains(
-          host->GetID());
+  if (extensions::ProcessMap::Get(host->GetBrowserContext())
+          ->Contains(host->GetID())) {
+    histogram_type = RENDERER_TYPE_EXTENSION;
+    was_extension_process = true;
+  }
 #endif
   if (status == base::TERMINATION_STATUS_PROCESS_CRASHED ||
       status == base::TERMINATION_STATUS_ABNORMAL_TERMINATION) {
     if (was_extension_process) {
       IncrementPrefValue(prefs::kStabilityExtensionRendererCrashCount);
 
       UMA_HISTOGRAM_SPARSE_SLOWLY("CrashExitCodes.Extension",
                                   MapCrashExitCodeForHistogram(exit_code));
     } else {
       IncrementPrefValue(prefs::kStabilityRendererCrashCount);
 
       UMA_HISTOGRAM_SPARSE_SLOWLY("CrashExitCodes.Renderer",
                                   MapCrashExitCodeForHistogram(exit_code));
     }
 
-    UMA_HISTOGRAM_PERCENTAGE("BrowserRenderProcessHost.ChildCrashes",
-                             was_extension_process ? 2 : 1);
+    UMA_HISTOGRAM_ENUMERATION("BrowserRenderProcessHost.ChildCrashes",
+                              histogram_type, RENDERER_TYPE_COUNT);
   } else if (status == base::TERMINATION_STATUS_PROCESS_WAS_KILLED) {
-    RecordChildKills(was_extension_process);
+    RecordChildKills(histogram_type);
 #if defined(OS_CHROMEOS)
   } else if (status == base::TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM) {
-    RecordChildKills(was_extension_process);
+    RecordChildKills(histogram_type);
     UMA_HISTOGRAM_ENUMERATION("BrowserRenderProcessHost.ChildKills.OOM",
                               was_extension_process ? 2 : 1,
                               3);
     memory::RecordMemoryStats(
         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);
+    UMA_HISTOGRAM_ENUMERATION("BrowserRenderProcessHost.DisconnectedAlive",
+                              histogram_type, RENDERER_TYPE_COUNT);
+  } else if (status == base::TERMINATION_STATUS_LAUNCH_FAILED) {
+    UMA_HISTOGRAM_ENUMERATION("BrowserRenderProcessHost.ChildLaunchFailures",
+                              histogram_type, RENDERER_TYPE_COUNT);
+    // Treat child process launch as a crash for now.
+    if (was_extension_process)
+      IncrementPrefValue(prefs::kStabilityExtensionRendererCrashCount);
+    else
+      IncrementPrefValue(prefs::kStabilityRendererCrashCount);
   }
 }
 
 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);
 }