Added histograms on process singleton create when remote process exists and we cannot notify it

chrome/browser/process_singleton_win.cc

 // Copyright (c) 2012 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/process_singleton.h"
 
 #include <windows.h>
 #include <shellapi.h>
 #include <stddef.h>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/debug/activity_tracker.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/process/process.h"
 #include "base/process/process_info.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_handle.h"
@@ skipping 147 matching lines @@
   return true;
 }
 
 bool DisplayShouldKillMessageBox() {
   return chrome::ShowQuestionMessageBox(
              NULL, l10n_util::GetStringUTF16(IDS_PRODUCT_NAME),
              l10n_util::GetStringUTF16(IDS_BROWSER_HUNGBROWSER_MESSAGE)) !=
          chrome::MESSAGE_BOX_RESULT_NO;
 }
 
+// Function was copied from Process::Terminate.
+void TerminateProcessWithHistograms(const base::Process& process,
+                                    int exit_code) {
+  DCHECK(process.IsValid());
+  base::TimeTicks start_time = base::TimeTicks::Now();
+  bool result = (::TerminateProcess(process.Handle(), exit_code) != FALSE);
+  DWORD terminate_error = 0;
+  if (result) {
+    DWORD wait_error = 0;
+    // The process may not end immediately due to pending I/O
+    DWORD wait_result = ::WaitForSingleObject(process.Handle(), 60 * 1000);
+    if (wait_result != WAIT_OBJECT_0) {
+      if (wait_result == WAIT_FAILED)
+        wait_error = ::GetLastError();
+      UMA_HISTOGRAM_ENUMERATION(
+          "Chrome.ProcessSingleton.RemoteProcessInteractionResult",
+          ProcessSingleton::TERMINATE_WAIT_TIMEOUT,
+          ProcessSingleton::MAX_HUNG_REMOTE_PROCESS_ACTION);
+      DPLOG(ERROR) << "Error waiting for process exit";
+    } else {
+      UMA_HISTOGRAM_ENUMERATION(
+          "Chrome.ProcessSingleton.RemoteProcessInteractionResult",
+          ProcessSingleton::TERMINATE_SUCCEEDED,
+          ProcessSingleton::MAX_HUNG_REMOTE_PROCESS_ACTION);
+    }
+    UMA_HISTOGRAM_TIMES("Chrome.ProcessSingleton.TerminateProcessTime",
+                        base::TimeTicks::Now() - start_time);
+    UMA_HISTOGRAM_SPARSE_SLOWLY(
+        "Chrome.ProcessSingleton.TerminationWaitErrorCode.Windows", wait_error);
+    base::debug::GlobalActivityTracker::RecordProcessExitIfEnabled(
+        process.Pid(), exit_code);
+  } else {
+    terminate_error = ::GetLastError();
+    UMA_HISTOGRAM_ENUMERATION(
+        "Chrome.ProcessSingleton.RemoteProcessInteractionResult",
+        ProcessSingleton::TERMINATE_FAILED,
+        ProcessSingleton::MAX_HUNG_REMOTE_PROCESS_ACTION);
+    DPLOG(ERROR) << "Unable to terminate process";
+  }
+  UMA_HISTOGRAM_SPARSE_SLOWLY(
+      "Chrome.ProcessSingleton.ProcessTerminateErrorCode.Windows",

[gab, 2017/05/10 15:16:50]

These histograms will be examined filtered per platform anyways, so I don't
think we need different names.

Just like say "Chrome.ProcessSingleton.RemoteProcessInteractionResult" doesn't
mean the same thing on each platform.

[Alexey Seren, 2017/05/11 13:42:05]

Unfortunately we cannot do it because each platform specific histogram has it
own enum (see histograms.xml):


<histogram name="Chrome.ProcessSingleton.TerminateProcessErrorCode.Posix"
    enum="OSAgnosticErrno">
  <owner>aseren@yandex-team.ru</owner>
  <summary>
    The error code of remote process termination on Posix in case when remote
    process hung.
  </summary>
</histogram>

<histogram name="Chrome.ProcessSingleton.TerminateProcessErrorCode.Windows"
    enum="WinGetLastError">
  <owner>aseren@yandex-team.ru</owner>
  <summary>
    The error code of remote process termination on Windows in case when remote
    process hung.
  </summary>
</histogram>

[gab, 2017/05/11 15:10:03]

s/OSAgnosticErrno/PosixErrno/ (maybe there's already such a suffix in
histograms.xml? I didn't look...)

+      terminate_error);
+}
+
 }  // namespace
 
 // Microsoft's Softricity virtualization breaks the sandbox processes.
 // So, if we detect the Softricity DLL we use WMI Win32_Process.Create to
 // break out of the virtualization environment.
 // http://code.google.com/p/chromium/issues/detail?id=43650
 bool ProcessSingleton::EscapeVirtualization(
     const base::FilePath& user_data_dir) {
   if (::GetModuleHandle(L"sftldr_wow64.dll") ||
       ::GetModuleHandle(L"sftldr.dll")) {
@@ skipping 44 matching lines @@
     return LOCK_ERROR;
   } else if (!remote_window_) {
     return PROCESS_NONE;
   }
 
   switch (chrome::AttemptToNotifyRunningChrome(remote_window_, false)) {
     case chrome::NOTIFY_SUCCESS:
       return PROCESS_NOTIFIED;
     case chrome::NOTIFY_FAILED:
       remote_window_ = NULL;
+      UMA_HISTOGRAM_ENUMERATION(
+          "Chrome.ProcessSingleton.RemoteProcessInteractionResult",
+          RUNNING_PROCESS_NOTIFY_FAILED, MAX_HUNG_REMOTE_PROCESS_ACTION);
       return PROCESS_NONE;
     case chrome::NOTIFY_WINDOW_HUNG:
       // Fall through and potentially terminate the hung browser.
       break;
   }
 
   // The window is hung.
   DWORD process_id = 0;
   DWORD thread_id = ::GetWindowThreadProcessId(remote_window_, &process_id);
   if (!thread_id || !process_id) {
+    UMA_HISTOGRAM_ENUMERATION(
+        "Chrome.ProcessSingleton.RemoteProcessInteractionResult",
+        REMOTE_PROCESS_NOT_FOUND, MAX_HUNG_REMOTE_PROCESS_ACTION);
     remote_window_ = NULL;
     return PROCESS_NONE;
   }
 
   // Get a handle to the process that created the window.
   base::Process process = base::Process::Open(process_id);
 
   // TODO(manzagop): capture a hang report.
 
   // Scan for every window to find a visible one.
   bool visible_window = false;
   ::EnumThreadWindows(thread_id,
                       &BrowserWindowEnumeration,
                       reinterpret_cast<LPARAM>(&visible_window));
 
   // If there is a visible browser window, ask the user before killing it.
   if (visible_window && !should_kill_remote_process_callback_.Run()) {
     // The user denied. Quit silently.
     return PROCESS_NOTIFIED;
   }
+  UMA_HISTOGRAM_ENUMERATION(
+      "Chrome.ProcessSingleton.RemoteHungProcessTerminateReason",
+      visible_window ? USER_ACCEPTED_TERMINATION : NO_VISIBLE_WINDOW_FOUND,
+      MAX_REMOTE_HUNG_PROCESS_TERMINATE_REASON);
 
   // Time to take action. Kill the browser process.
-  process.Terminate(content::RESULT_CODE_HUNG, true);
+  TerminateProcessWithHistograms(process, content::RESULT_CODE_HUNG);
+
   remote_window_ = NULL;
   return PROCESS_NONE;
 }
 
 ProcessSingleton::NotifyResult
 ProcessSingleton::NotifyOtherProcessOrCreate() {
   const base::TimeTicks begin_ticks = base::TimeTicks::Now();
   for (int i = 0; i < 2; ++i) {
     if (Create()) {
       UMA_HISTOGRAM_MEDIUM_TIMES("Chrome.ProcessSingleton.TimeToCreate",
@@ skipping 83 matching lines @@
   return window_.hwnd() != NULL;
 }
 
 void ProcessSingleton::Cleanup() {
 }
 
 void ProcessSingleton::OverrideShouldKillRemoteProcessCallbackForTesting(
     const ShouldKillRemoteProcessCallback& display_dialog_callback) {
   should_kill_remote_process_callback_ = display_dialog_callback;
 }