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

chrome/browser/process_singleton_win_unittest.cc

 // Copyright 2015 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 <memory>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/process/launch.h"
 #include "base/process/process.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
+#include "base/test/histogram_tester.h"
 #include "base/test/multiprocess_test.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/wrapped_window_proc.h"
 #include "chrome/browser/win/chrome_process_finder.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/common/result_codes.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/multiprocess_func_list.h"
 
@@ skipping 195 matching lines @@
                    base::Unretained(this), allow_kill));
   }
 
   base::Process* browser_victim() { return &(browser_victim_.process); }
   const base::FilePath& user_data_dir() const {
     return user_data_dir_.GetPath();
   }
   ProcessSingleton* test_singleton() const { return test_singleton_.get(); }
   bool should_kill_called() const { return should_kill_called_; }
 
+  const base::HistogramTester& histogram_tester() const {
+    return histogram_tester_;
+  }
+
  private:
   bool MockShouldKillRemoteProcess(bool allow_kill) {
     should_kill_called_ = true;
     return allow_kill;
   }
 
   base::string16 ready_event_name_;
   base::string16 continue_event_name_;
 
   WindowOption window_option_;
   base::ScopedTempDir user_data_dir_;
   base::SpawnChildResult browser_victim_;
   base::win::ScopedHandle continue_event_;
 
   std::unique_ptr<ProcessSingleton> test_singleton_;
 
   base::TimeDelta old_notification_timeout_;
   bool should_kill_called_;
+  base::HistogramTester histogram_tester_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessSingletonTest);
 };
 
 }  // namespace
 
 TEST_F(ProcessSingletonTest, KillsHungBrowserWithNoWindows) {
   ASSERT_NO_FATAL_FAILURE(PrepareTest(NO_WINDOW, false));
 
   // As the hung browser has no visible window, it'll be killed without
   // user interaction.
   ProcessSingleton::NotifyResult notify_result =
       test_singleton()->NotifyOtherProcessOrCreate();
 
   // The hung process was killed and the notification is equivalent to
   // a non existent process.
   ASSERT_EQ(ProcessSingleton::PROCESS_NONE, notify_result);
 
   // The should-kill callback should not have been called, as the "browser" does
   // not have visible window.
   EXPECT_FALSE(should_kill_called());
 
+  histogram_tester().ExpectUniqueSample(
+      "Chrome.ProcessSingleton.RemoteProcessInteractionResult",
+      ProcessSingleton::TERMINATE_SUCCEEDED, 1u);
+  histogram_tester().ExpectTotalCount(
+      "Chrome.ProcessSingleton.TerminateProcessTime", 1u);
+  histogram_tester().ExpectUniqueSample(
+      "Chrome.ProcessSingleton.ProcessTerminateErrorCode.Windows", 0, 1u);
+  histogram_tester().ExpectUniqueSample(
+      "Chrome.ProcessSingleton.TerminationWaitErrorCode.Windows", 0, 1u);
+  histogram_tester().ExpectUniqueSample(
+      "Chrome.ProcessSingleton.RemoteHungProcessTerminateReason",
+      ProcessSingleton::NO_VISIBLE_WINDOW_FOUND, 1u);
+
   // Verify that the hung browser has been terminated with the
   // RESULT_CODE_HUNG exit code.
   int exit_code = 0;
   EXPECT_TRUE(
       browser_victim()->WaitForExitWithTimeout(base::TimeDelta(), &exit_code));
   EXPECT_EQ(content::RESULT_CODE_HUNG, exit_code);
 }
 
 TEST_F(ProcessSingletonTest, DoesntKillWithoutUserPermission) {
   ASSERT_NO_FATAL_FAILURE(PrepareTest(WITH_WINDOW, false));
 
   // As the hung browser has a visible window, this should query the user
   // before killing the hung process.
   ProcessSingleton::NotifyResult notify_result =
       test_singleton()->NotifyOtherProcessOrCreate();
   ASSERT_EQ(ProcessSingleton::PROCESS_NOTIFIED, notify_result);
 
   // The should-kill callback should have been called, as the "browser" has a
   // visible window.
   EXPECT_TRUE(should_kill_called());
 
+  histogram_tester().ExpectTotalCount(
+      "Chrome.ProcessSingleton.RemoteProcessInteractionResult", 0);
+
   // Make sure the process hasn't been killed.
   int exit_code = 0;
   EXPECT_FALSE(
       browser_victim()->WaitForExitWithTimeout(base::TimeDelta(), &exit_code));
 }
 
 TEST_F(ProcessSingletonTest, KillWithUserPermission) {
   ASSERT_NO_FATAL_FAILURE(PrepareTest(WITH_WINDOW, true));
 
   // As the hung browser has a visible window, this should query the user
   // before killing the hung process.
   ProcessSingleton::NotifyResult notify_result =
       test_singleton()->NotifyOtherProcessOrCreate();
 
   // The hung process was killed and the notification is equivalent to
   // a non existent process.
   ASSERT_EQ(ProcessSingleton::PROCESS_NONE, notify_result);
 
   // The should-kill callback should have been called, as the "browser" has a
   // visible window.
   EXPECT_TRUE(should_kill_called());
 
+  histogram_tester().ExpectUniqueSample(
+      "Chrome.ProcessSingleton.RemoteProcessInteractionResult",
+      ProcessSingleton::TERMINATE_SUCCEEDED, 1u);
+  histogram_tester().ExpectTotalCount(
+      "Chrome.ProcessSingleton.TerminateProcessTime", 1u);
+  histogram_tester().ExpectUniqueSample(
+      "Chrome.ProcessSingleton.ProcessTerminateErrorCode.Windows", 0, 1u);
+  histogram_tester().ExpectUniqueSample(
+      "Chrome.ProcessSingleton.TerminationWaitErrorCode.Windows", 0, 1u);
+  histogram_tester().ExpectUniqueSample(
+      "Chrome.ProcessSingleton.RemoteHungProcessTerminateReason",
+      ProcessSingleton::USER_ACCEPTED_TERMINATION, 1u);
+
   // Verify that the hung browser has been terminated with the
   // RESULT_CODE_HUNG exit code.
   int exit_code = 0;
   EXPECT_TRUE(
       browser_victim()->WaitForExitWithTimeout(base::TimeDelta(), &exit_code));
   EXPECT_EQ(content::RESULT_CODE_HUNG, exit_code);
 }