Add stats to distinguish android renderer crashes.

components/crash/content/browser/crash_dump_manager_android.cc

 // Copyright 2013 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 "components/crash/content/browser/crash_dump_manager_android.h"
 
+#include "base/android/application_status_listener.h"
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/posix/global_descriptors.h"
 #include "base/process/process.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/file_descriptor_info.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
@@ skipping 54 matching lines @@
   {
     base::AutoLock auto_lock(child_process_id_to_minidump_path_lock_);
     DCHECK(!ContainsKey(child_process_id_to_minidump_path_, child_process_id));
     child_process_id_to_minidump_path_[child_process_id] = minidump_path;
   }
   return minidump_file.Pass();
 }
 
 // static
 void CrashDumpManager::ProcessMinidump(const base::FilePath& minidump_path,
-                                       base::ProcessHandle pid) {
+                                       base::ProcessHandle pid,
+                                       content::ProcessType process_type,
+                                       base::TerminationStatus exit_status,
+                                       int app_state) {

[no sievers, 2015/11/19 20:43:27]

can you change int to |ApplicationState|? and then introduce _UNKNOWN and use it
instead of 0. 

[Peter Wen, 2015/11/19 21:01:25]

Done.

   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   CHECK(instance_);
   int64 file_size = 0;
   int r = base::GetFileSize(minidump_path, &file_size);
   DCHECK(r) << "Failed to retrieve size for minidump "
             << minidump_path.value();
 
+  if (process_type == content::PROCESS_TYPE_RENDERER &&
+      exit_status == base::TERMINATION_STATUS_OOM_PROTECTED) {
+    bool is_running =
+        (app_state == base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES);
+    bool is_paused =
+        (app_state == base::android::APPLICATION_STATE_HAS_PAUSED_ACTIVITIES);
+    ExitStatus renderer_exit_status;
+    if (file_size == 0) {
+      if (is_running) {
+        renderer_exit_status = EMPTY_MINIDUMP_WHILE_RUNNING;
+      } else if (is_paused) {
+        renderer_exit_status = EMPTY_MINIDUMP_WHILE_PAUSED;
+      } else {
+        renderer_exit_status = EMPTY_MINIDUMP_WHILE_BACKGROUND;
+      }
+    } else {
+      if (is_running) {
+        renderer_exit_status = VALID_MINIDUMP_WHILE_RUNNING;
+      } else if (is_paused) {
+        renderer_exit_status = VALID_MINIDUMP_WHILE_PAUSED;
+      } else {
+        renderer_exit_status = VALID_MINIDUMP_WHILE_BACKGROUND;
+      }
+    }
+    UMA_HISTOGRAM_ENUMERATION("Tab.RendererDetailedExitStatus",
+                              renderer_exit_status,
+                              ExitStatus::COUNT);
+  }
+
   if (file_size == 0) {
     // Empty minidump, this process did not crash. Just remove the file.
     r = base::DeleteFile(minidump_path, false);
     DCHECK(r) << "Failed to delete temporary minidump file "
               << minidump_path.value();
     return;
   }
 
   // We are dealing with a valid minidump. Copy it to the crash report
   // directory from where Java code will upload it later on.
@@ skipping 12 matching lines @@
                << " to " << dest_path.value();
     base::DeleteFile(minidump_path, false);
     return;
   }
   VLOG(1) << "Crash minidump successfully generated: " <<
       instance_->crash_dump_dir_.Append(filename).value();
 }
 
 void CrashDumpManager::BrowserChildProcessHostDisconnected(
     const content::ChildProcessData& data) {
-  OnChildExit(data.id, data.handle);
+  OnChildExit(data.id,
+              data.handle,
+              static_cast<content::ProcessType>(data.process_type),
+              // Disconnects don't have a specific termination status.
+              /* exit_status */ base::TERMINATION_STATUS_MAX_ENUM,
+              /* app_state */ 0);
 }
 
 void CrashDumpManager::BrowserChildProcessCrashed(
     const content::ChildProcessData& data,
     int exit_code) {
-  OnChildExit(data.id, data.handle);
+  OnChildExit(data.id,
+              data.handle,
+              static_cast<content::ProcessType>(data.process_type),
+              /* exit_status */ base::TERMINATION_STATUS_ABNORMAL_TERMINATION,
+              /* app_state */ 0);
 }
 
 void CrashDumpManager::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED:
       // NOTIFICATION_RENDERER_PROCESS_TERMINATED is sent when the renderer
       // process is cleanly shutdown. However, we need to fallthrough so that
       // we close the minidump_fd we kept open.
     case content::NOTIFICATION_RENDERER_PROCESS_CLOSED: {
       content::RenderProcessHost* rph =
           content::Source<content::RenderProcessHost>(source).ptr();
-      OnChildExit(rph->GetID(), rph->GetHandle());
+      content::RenderProcessHost::RendererClosedDetails* process_details =
+          content::Details<content::RenderProcessHost::RendererClosedDetails>(
+              details).ptr();
+      OnChildExit(rph->GetID(),
+                  rph->GetHandle(),
+                  content::PROCESS_TYPE_RENDERER,
+                  process_details->status,
+                  base::android::ApplicationStatusListener::GetState());

[no sievers, 2015/11/19 20:43:27]

why pass GetState() and not call it where you are using it above?
that way there's not risk of using the wrong value.

[Peter Wen, 2015/11/19 21:01:26]

We want the application state as close to when the renderer died as possible, as
the state is likely to change the longer we wait. Since ProcessMinidump is run
on the FILE thread, it may be blocked for a while, making the stat less
accurate.

It is also only needed for the renderer, so I chose to call and pass it here
instead of OnChildExit.

       break;
     }
     default:
       NOTREACHED();
       return;
   }
 }
 
 void CrashDumpManager::OnChildExit(int child_process_id,
-                                   base::ProcessHandle pid) {
+                                   base::ProcessHandle pid,
+                                   content::ProcessType process_type,
+                                   base::TerminationStatus exit_status,
+                                   int app_state) {
   base::FilePath minidump_path;
   {
     base::AutoLock auto_lock(child_process_id_to_minidump_path_lock_);
     ChildProcessIDToMinidumpPath::iterator iter =
         child_process_id_to_minidump_path_.find(child_process_id);
     if (iter == child_process_id_to_minidump_path_.end()) {
       // We might get a NOTIFICATION_RENDERER_PROCESS_TERMINATED and a
       // NOTIFICATION_RENDERER_PROCESS_CLOSED.
       return;
     }
     minidump_path = iter->second;
     child_process_id_to_minidump_path_.erase(iter);
   }
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
-      base::Bind(&CrashDumpManager::ProcessMinidump, minidump_path, pid));
+      base::Bind(&CrashDumpManager::ProcessMinidump,
+                 minidump_path,
+                 pid,
+                 process_type,
+                 exit_status,
+                 app_state));
 }
 
 }  // namespace breakpad