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

chrome/browser/process_singleton_posix_unittest.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/process_singleton.h"
 
 #include <fcntl.h>
 #include <limits.h>
 #include <signal.h>
 #include <stddef.h>
 #include <sys/types.h>
 #include <sys/un.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/test/histogram_tester.h"
 #include "base/test/test_timeouts.h"
 #include "base/test/thread_test_helper.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "chrome/common/chrome_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/base/network_interfaces.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 34 matching lines @@
         wait_event_(base::WaitableEvent::ResetPolicy::MANUAL,
                     base::WaitableEvent::InitialState::NOT_SIGNALED),
         signal_event_(base::WaitableEvent::ResetPolicy::MANUAL,
                       base::WaitableEvent::InitialState::NOT_SIGNALED),
         process_singleton_on_thread_(NULL) {}
 
   void SetUp() override {
     testing::Test::SetUp();
 
     ProcessSingleton::DisablePromptForTesting();
+    ProcessSingleton::SkipIsChromeProcessCheckForTesting(false);
     // Put the lock in a temporary directory.  Doesn't need to be a
     // full profile to test this code.
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     // Use a long directory name to ensure that the socket isn't opened through
     // the symlink.
     user_data_path_ = temp_dir_.GetPath().Append(
         std::string(sizeof(sockaddr_un::sun_path), 'a'));
     ASSERT_TRUE(CreateDirectory(user_data_path_));
 
     lock_path_ = user_data_path_.Append(chrome::kSingletonLockFilename);
@@ skipping 185 matching lines @@
 // TODO(james.su@gmail.com): port following tests to Windows.
 // Test success case of NotifyOtherProcess().
 TEST_F(ProcessSingletonPosixTest, NotifyOtherProcessSuccess) {
   CreateProcessSingletonOnThread();
   EXPECT_EQ(ProcessSingleton::PROCESS_NOTIFIED, NotifyOtherProcess(true));
   CheckNotified();
 }
 
 // Test failure case of NotifyOtherProcess().
 TEST_F(ProcessSingletonPosixTest, NotifyOtherProcessFailure) {
+  base::HistogramTester histogram_tester;
   CreateProcessSingletonOnThread();
 
   BlockWorkerThread();
   EXPECT_EQ(ProcessSingleton::PROCESS_NONE, NotifyOtherProcess(true));
   ASSERT_EQ(1, kill_callbacks_);
   UnblockWorkerThread();
+  histogram_tester.ExpectUniqueSample(
+      "Chrome.ProcessSingleton.RemoteHungProcessTerminateReason",
+      ProcessSingleton::SOCKET_READ_FAILED, 1u);
 }
 
 // Test that we don't kill ourselves by accident if a lockfile with the same pid
 // happens to exist.
 TEST_F(ProcessSingletonPosixTest, NotifyOtherProcessNoSuicide) {
+  base::HistogramTester histogram_tester;
   CreateProcessSingletonOnThread();
   // Replace lockfile with one containing our own pid.
   EXPECT_EQ(0, unlink(lock_path_.value().c_str()));
   std::string symlink_content = base::StringPrintf(
       "%s%c%u",
       net::GetHostName().c_str(),
       '-',
       base::GetCurrentProcId());
   EXPECT_EQ(0, symlink(symlink_content.c_str(), lock_path_.value().c_str()));
 
   // Remove socket so that we will not be able to notify the existing browser.
   EXPECT_EQ(0, unlink(socket_path_.value().c_str()));
 
+  // Pretend we are browser process.
+  ProcessSingleton::SkipIsChromeProcessCheckForTesting(true);
+
   EXPECT_EQ(ProcessSingleton::PROCESS_NONE, NotifyOtherProcess(false));
   // If we've gotten to this point without killing ourself, the test succeeded.
+  histogram_tester.ExpectUniqueSample(
+      "Chrome.ProcessSingleton.RemoteProcessInteractionResult",
+      ProcessSingleton::SAME_BROWSER_INSTANCE, 1u);
 }
 
 // Test that we can still notify a process on the same host even after the
 // hostname changed.
 TEST_F(ProcessSingletonPosixTest, NotifyOtherProcessHostChanged) {
   CreateProcessSingletonOnThread();
   EXPECT_EQ(0, unlink(lock_path_.value().c_str()));
   EXPECT_EQ(0, symlink("FAKEFOOHOST-1234", lock_path_.value().c_str()));
 
   EXPECT_EQ(ProcessSingleton::PROCESS_NOTIFIED, NotifyOtherProcess(false));
@@ skipping 76 matching lines @@
 
   // Also change the hostname, so the remote does not retry.
   EXPECT_EQ(0, unlink(lock_path_.value().c_str()));
   EXPECT_EQ(0, symlink("FAKEFOOHOST-1234", lock_path_.value().c_str()));
 
   std::string url("about:blank");
   EXPECT_EQ(ProcessSingleton::PROFILE_IN_USE, NotifyOtherProcessOrCreate(url));
 }
 
 TEST_F(ProcessSingletonPosixTest, IgnoreSocketSymlinkWithTooLongTarget) {
+  base::HistogramTester histogram_tester;
   CreateProcessSingletonOnThread();
   // Change the symlink to one with a too-long target.
   char buf[PATH_MAX];
   ssize_t len = readlink(socket_path_.value().c_str(), buf, PATH_MAX);
   ASSERT_GT(len, 0);
   base::FilePath socket_target_path = base::FilePath(std::string(buf, len));
   base::FilePath long_socket_target_path = socket_target_path.DirName().Append(
       std::string(sizeof(sockaddr_un::sun_path), 'b'));
   ASSERT_EQ(0, unlink(socket_path_.value().c_str()));
   ASSERT_EQ(0, symlink(long_socket_target_path.value().c_str(),
                        socket_path_.value().c_str()));
 
   // A new ProcessSingleton should ignore the invalid socket path target.
   std::string url("about:blank");
   EXPECT_EQ(ProcessSingleton::PROCESS_NONE, NotifyOtherProcessOrCreate(url));
+
+  // Lock file contains PID of unit_tests process. It is non browser process so
+  // we treat lock file as orphaned.
+  histogram_tester.ExpectUniqueSample(
+      "Chrome.ProcessSingleton.RemoteProcessInteractionResult",
+      ProcessSingleton::ORPHANED_LOCK_FILE, 1u);
 }
 
 #if defined(OS_MACOSX)
 // Test that if there is an existing lock file, and we could not flock()
 // it, then exit.
 TEST_F(ProcessSingletonPosixTest, CreateRespectsOldMacLock) {
   std::unique_ptr<TestableProcessSingleton> process_singleton(
       CreateProcessSingleton());
   base::ScopedFD lock_fd(HANDLE_EINTR(
       open(lock_path_.value().c_str(), O_RDWR | O_CREAT | O_EXLOCK, 0644)));
   ASSERT_TRUE(lock_fd.is_valid());
   EXPECT_FALSE(process_singleton->Create());
   base::File::Info info;
   EXPECT_TRUE(base::GetFileInfo(lock_path_, &info));
   EXPECT_FALSE(info.is_directory);
   EXPECT_FALSE(info.is_symbolic_link);
 }
 
 // Test that if there is an existing lock file, and it's not locked, we replace
 // it.
 TEST_F(ProcessSingletonPosixTest, CreateReplacesOldMacLock) {
   std::unique_ptr<TestableProcessSingleton> process_singleton(
       CreateProcessSingleton());
   EXPECT_EQ(0, base::WriteFile(lock_path_, "", 0));
   EXPECT_TRUE(process_singleton->Create());
   VerifyFiles();
 }
 #endif  // defined(OS_MACOSX)