Speed up and re-enable ProcessSingletonPosixTest tests.

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 <signal.h>
 #include <sys/types.h>
 #include <sys/un.h>
@@ skipping 142 matching lines @@
     ASSERT_GT(len, 0);
     std::string cookie(buf, len);
 
     base::FilePath remote_cookie_path = socket_target_path.DirName().
         Append(chrome::kSingletonCookieFilename);
     len = readlink(remote_cookie_path.value().c_str(), buf, PATH_MAX);
     ASSERT_GT(len, 0);
     EXPECT_EQ(cookie, std::string(buf, len));
   }
 
-  ProcessSingleton::NotifyResult NotifyOtherProcess(
-      bool override_kill,
-      base::TimeDelta timeout) {
+  ProcessSingleton::NotifyResult NotifyOtherProcess(bool override_kill) {
     scoped_ptr<TestableProcessSingleton> process_singleton(
         CreateProcessSingleton());
     CommandLine command_line(CommandLine::ForCurrentProcess()->GetProgram());
     command_line.AppendArg("about:blank");
     if (override_kill) {
       process_singleton->OverrideCurrentPidForTesting(
           base::GetCurrentProcId() + 1);
       process_singleton->OverrideKillCallbackForTesting(
           base::Bind(&ProcessSingletonPosixTest::KillCallback,
                      base::Unretained(this)));
     }
 
     return process_singleton->NotifyOtherProcessWithTimeout(
-        command_line, timeout.InSeconds(), true);
+        command_line, kRetryAttempts, timeout(), true);
   }
 
   // A helper method to call ProcessSingleton::NotifyOtherProcessOrCreate().
   ProcessSingleton::NotifyResult NotifyOtherProcessOrCreate(
-      const std::string& url,
-      base::TimeDelta timeout) {
+      const std::string& url) {
     scoped_ptr<TestableProcessSingleton> process_singleton(
         CreateProcessSingleton());
     CommandLine command_line(CommandLine::ForCurrentProcess()->GetProgram());
     command_line.AppendArg(url);
     return process_singleton->NotifyOtherProcessWithTimeoutOrCreate(
-        command_line, timeout.InSeconds());
+        command_line, kRetryAttempts, timeout());
   }
 
   void CheckNotified() {
     ASSERT_TRUE(process_singleton_on_thread_ != NULL);
     ASSERT_EQ(1u, process_singleton_on_thread_->callback_command_lines_.size());
     bool found = false;
     for (size_t i = 0;
          i < process_singleton_on_thread_->callback_command_lines_[0].size();
          ++i) {
       if (process_singleton_on_thread_->callback_command_lines_[0][i] ==
@@ skipping 23 matching lines @@
     signal_event_.Signal();
   }
 
   base::FilePath user_data_path_;
   base::FilePath lock_path_;
   base::FilePath socket_path_;
   base::FilePath cookie_path_;
   int kill_callbacks_;
 
  private:
+  static const int kRetryAttempts = 2;
+
+  base::TimeDelta timeout() const {
+    return TestTimeouts::tiny_timeout() * kRetryAttempts;
+  }
+
   void CreateProcessSingletonInternal() {
     ASSERT_TRUE(!process_singleton_on_thread_);
     process_singleton_on_thread_ = CreateProcessSingleton();
     ASSERT_EQ(ProcessSingleton::PROCESS_NONE,
               process_singleton_on_thread_->NotifyOtherProcessOrCreate());
   }
 
   void DestructProcessSingleton() {
     ASSERT_TRUE(process_singleton_on_thread_);
     delete process_singleton_on_thread_;
@@ skipping 19 matching lines @@
 // If this test flakes, use http://crbug.com/74554.
 TEST_F(ProcessSingletonPosixTest, CheckSocketFile) {
   CreateProcessSingletonOnThread();
   VerifyFiles();
 }
 
 // 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, TestTimeouts::action_timeout()));
+  EXPECT_EQ(ProcessSingleton::PROCESS_NOTIFIED, NotifyOtherProcess(true));
   CheckNotified();
 }
 
 // Test failure case of NotifyOtherProcess().
-// Disabled, http://crbug.com/407065 .
-TEST_F(ProcessSingletonPosixTest, DISABLED_NotifyOtherProcessFailure) {
+TEST_F(ProcessSingletonPosixTest, NotifyOtherProcessFailure) {
   CreateProcessSingletonOnThread();
 
   BlockWorkerThread();
-  EXPECT_EQ(ProcessSingleton::PROCESS_NONE,
-            NotifyOtherProcess(true, TestTimeouts::action_timeout()));
-
+  EXPECT_EQ(ProcessSingleton::PROCESS_NONE, NotifyOtherProcess(true));
   ASSERT_EQ(1, kill_callbacks_);
   UnblockWorkerThread();
 }
 
 // Test that we don't kill ourselves by accident if a lockfile with the same pid
 // happens to exist.
 TEST_F(ProcessSingletonPosixTest, NotifyOtherProcessNoSuicide) {
   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()));
 
-  EXPECT_EQ(ProcessSingleton::PROCESS_NONE,
-            NotifyOtherProcess(false, TestTimeouts::action_timeout()));
+  EXPECT_EQ(ProcessSingleton::PROCESS_NONE, NotifyOtherProcess(false));
   // If we've gotten to this point without killing ourself, the test succeeded.
 }
 
 // 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, TestTimeouts::action_timeout()));
+  EXPECT_EQ(ProcessSingleton::PROCESS_NOTIFIED, NotifyOtherProcess(false));
   CheckNotified();
 }
 
 // Test that we fail when lock says process is on another host and we can't
 // notify it over the socket.
-// Disabled, http://crbug.com/407065 .
-TEST_F(ProcessSingletonPosixTest, DISABLED_NotifyOtherProcessDifferingHost) {
+TEST_F(ProcessSingletonPosixTest, NotifyOtherProcessDifferingHost) {
   CreateProcessSingletonOnThread();
 
   BlockWorkerThread();
 
   EXPECT_EQ(0, unlink(lock_path_.value().c_str()));
   EXPECT_EQ(0, symlink("FAKEFOOHOST-1234", lock_path_.value().c_str()));
 
-  EXPECT_EQ(ProcessSingleton::PROFILE_IN_USE,
-            NotifyOtherProcess(false, TestTimeouts::action_timeout()));
+  EXPECT_EQ(ProcessSingleton::PROFILE_IN_USE, NotifyOtherProcess(false));
 
   ASSERT_EQ(0, unlink(lock_path_.value().c_str()));
 
   UnblockWorkerThread();
 }
 
 // Test that we fail when lock says process is on another host and we can't
 // notify it over the socket.
-// Disabled, http://crbug.com/407065 .
-TEST_F(ProcessSingletonPosixTest,
-       DISABLED_NotifyOtherProcessOrCreate_DifferingHost) {
+TEST_F(ProcessSingletonPosixTest, NotifyOtherProcessOrCreate_DifferingHost) {
   CreateProcessSingletonOnThread();
 
   BlockWorkerThread();
 
   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, TestTimeouts::action_timeout()));
+  EXPECT_EQ(ProcessSingleton::PROFILE_IN_USE, NotifyOtherProcessOrCreate(url));
 
   ASSERT_EQ(0, unlink(lock_path_.value().c_str()));
 
   UnblockWorkerThread();
 }
 
 // Test that Create fails when another browser is using the profile directory.
 TEST_F(ProcessSingletonPosixTest, CreateFailsWithExistingBrowser) {
   CreateProcessSingletonOnThread();
 
@@ skipping 30 matching lines @@
   CreateProcessSingletonOnThread();
   // Change the cookie.
   EXPECT_EQ(0, unlink(cookie_path_.value().c_str()));
   EXPECT_EQ(0, symlink("INCORRECTCOOKIE", cookie_path_.value().c_str()));
 
   // 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, TestTimeouts::action_timeout()));
+  EXPECT_EQ(ProcessSingleton::PROFILE_IN_USE, NotifyOtherProcessOrCreate(url));
 }
 
 #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) {
   scoped_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) {
   scoped_ptr<TestableProcessSingleton> process_singleton(
       CreateProcessSingleton());
   EXPECT_EQ(0, base::WriteFile(lock_path_, "", 0));
   EXPECT_TRUE(process_singleton->Create());
   VerifyFiles();
 }
 #endif  // defined(OS_MACOSX)