Speed up and re-enable ProcessSingletonPosixTest tests.

chrome/browser/process_singleton_posix.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.
 
 // On Linux, when the user tries to launch a second copy of chrome, we check
 // for a socket in the user's profile directory.  If the socket file is open we
 // send a message to the first chrome browser process with the current
 // directory and second process command line flags.  The second process then
 // exits.
 //
@@ skipping 74 matching lines @@
 #if defined(OS_LINUX)
 #include "chrome/browser/ui/process_singleton_dialog_linux.h"
 #endif
 
 #if defined(TOOLKIT_VIEWS) && defined(OS_LINUX) && !defined(OS_CHROMEOS)
 #include "ui/views/linux_ui/linux_ui.h"
 #endif
 
 using content::BrowserThread;
 
-const int ProcessSingleton::kTimeoutInSeconds;
-
 namespace {
 
+// Timeout for the current browser process to respond. 20 seconds should be
+// enough.
+const int kTimeoutInSeconds = 20;
+// Number of retries to notify the browser. 20 retries over 20 seconds = 1 try
+// per second.
+const int kRetryAttempts = 20;
 static bool g_disable_prompt;
 const char kStartToken[] = "START";
 const char kACKToken[] = "ACK";
 const char kShutdownToken[] = "SHUTDOWN";
 const char kTokenDelimiter = '\0';
 const int kMaxMessageLength = 32 * 1024;
 const int kMaxACKMessageLength = arraysize(kShutdownToken) - 1;
 
 const char kLockDelimiter = '-';
 
@@ skipping 42 matching lines @@
       }
       PLOG(ERROR) << "write() failed";
       return false;
     }
     bytes_written += rv;
   } while (bytes_written < length);
 
   return true;
 }
 
-// Wait a socket for read for a certain timeout in seconds.
+struct timeval TimeDeltaToTimeVal(const base::TimeDelta& delta) {
+  struct timeval result;
+  result.tv_sec = delta.InSeconds();
+  result.tv_usec = delta.InMicroseconds() % base::Time::kMicrosecondsPerSecond;
+  return result;
+}
+
+// Wait a socket for read for a certain timeout.
 // Returns -1 if error occurred, 0 if timeout reached, > 0 if the socket is
 // ready for read.
-int WaitSocketForRead(int fd, int timeout) {
+int WaitSocketForRead(int fd, const base::TimeDelta& timeout) {
   fd_set read_fds;
-  struct timeval tv;
+  struct timeval tv = TimeDeltaToTimeVal(timeout);
 
   FD_ZERO(&read_fds);
   FD_SET(fd, &read_fds);
-  tv.tv_sec = timeout;
-  tv.tv_usec = 0;
 
   return HANDLE_EINTR(select(fd + 1, &read_fds, NULL, NULL, &tv));
 }
 
-// Read a message from a socket fd, with an optional timeout in seconds.
+// Read a message from a socket fd, with an optional timeout.
 // If |timeout| <= 0 then read immediately.
 // Return number of bytes actually read, or -1 on error.
-ssize_t ReadFromSocket(int fd, char *buf, size_t bufsize, int timeout) {
-  if (timeout > 0) {
+ssize_t ReadFromSocket(int fd,
+                       char* buf,
+                       size_t bufsize,
+                       const base::TimeDelta& timeout) {
+  if (timeout > base::TimeDelta()) {
     int rv = WaitSocketForRead(fd, timeout);
     if (rv <= 0)
       return rv;
   }
 
   size_t bytes_read = 0;
   do {
     ssize_t rv = HANDLE_EINTR(read(fd, buf + bytes_read, bufsize - bytes_read));
     if (rv < 0) {
       if (errno != EAGAIN && errno != EWOULDBLOCK) {
@@ skipping 546 matching lines @@
   cookie_path_ = user_data_dir.Append(chrome::kSingletonCookieFilename);
 
   kill_callback_ = base::Bind(&ProcessSingleton::KillProcess,
                               base::Unretained(this));
 }
 
 ProcessSingleton::~ProcessSingleton() {
 }
 
 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() {
-  return NotifyOtherProcessWithTimeout(*CommandLine::ForCurrentProcess(),
-                                       kTimeoutInSeconds,
-                                       true);
+  return NotifyOtherProcessWithTimeout(
+      *CommandLine::ForCurrentProcess(),
+      kRetryAttempts,
+      base::TimeDelta::FromSeconds(kTimeoutInSeconds),
+      true);
 }
 
 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessWithTimeout(
     const CommandLine& cmd_line,
-    int timeout_seconds,
+    int retry_attempts,
+    const base::TimeDelta& timeout_interval,
     bool kill_unresponsive) {
-  DCHECK_GE(timeout_seconds, 0);
+  DCHECK_GE(retry_attempts, 0);
+  DCHECK_GE(timeout_interval.InMicroseconds(), 0);
+
+  base::TimeDelta sleep_interval = timeout_interval / retry_attempts;
 
   ScopedSocket socket;
-  for (int retries = 0; retries <= timeout_seconds; ++retries) {
+  for (int retries = 0; retries <= retry_attempts; ++retries) {
     // Try to connect to the socket.
     if (ConnectSocket(&socket, socket_path_, cookie_path_))
       break;
 
     // If we're in a race with another process, they may be in Create() and have
     // created the lock but not attached to the socket.  So we check if the
     // process with the pid from the lockfile is currently running and is a
-    // chrome browser.  If so, we loop and try again for |timeout_seconds|.
+    // chrome browser.  If so, we loop and try again for |timeout_interval|.
 
     std::string hostname;
     int pid;
     if (!ParseLockPath(lock_path_, &hostname, &pid)) {
       // No lockfile exists.
       return PROCESS_NONE;
     }
 
     if (hostname.empty()) {
       // Invalid lockfile.
@@ skipping 17 matching lines @@
       return PROCESS_NONE;
     }
 
     if (IsSameChromeInstance(pid)) {
       // Orphaned lockfile (pid is part of same chrome instance we are, even
       // though we haven't tried to create a lockfile yet).
       UnlinkPath(lock_path_);
       return PROCESS_NONE;
     }
 
-    if (retries == timeout_seconds) {
+    if (retries == retry_attempts) {
       // Retries failed.  Kill the unresponsive chrome process and continue.
       if (!kill_unresponsive || !KillProcessByLockPath())
         return PROFILE_IN_USE;
       return PROCESS_NONE;
     }
 
-    base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
+    base::PlatformThread::Sleep(sleep_interval);
   }
 
-  timeval timeout = {timeout_seconds, 0};
+  timeval timeout = TimeDeltaToTimeVal(timeout_interval);
   setsockopt(socket.fd(), SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
 
   // Found another process, prepare our command line
   // format is "START\0<current dir>\0<argv[0]>\0...\0<argv[n]>".
   std::string to_send(kStartToken);
   to_send.push_back(kTokenDelimiter);
 
   base::FilePath current_dir;
   if (!PathService::Get(base::DIR_CURRENT, &current_dir))
     return PROCESS_NONE;
@@ skipping 14 matching lines @@
     return PROCESS_NONE;
   }
 
   if (shutdown(socket.fd(), SHUT_WR) < 0)
     PLOG(ERROR) << "shutdown() failed";
 
   // Read ACK message from the other process. It might be blocked for a certain
   // timeout, to make sure the other process has enough time to return ACK.
   char buf[kMaxACKMessageLength + 1];
   ssize_t len =
-      ReadFromSocket(socket.fd(), buf, kMaxACKMessageLength, timeout_seconds);
+      ReadFromSocket(socket.fd(), buf, kMaxACKMessageLength, timeout_interval);
 
   // Failed to read ACK, the other process might have been frozen.
   if (len <= 0) {
     if (!kill_unresponsive || !KillProcessByLockPath())
       return PROFILE_IN_USE;
     return PROCESS_NONE;
   }
 
   buf[len] = '\0';
   if (strncmp(buf, kShutdownToken, arraysize(kShutdownToken) - 1) == 0) {
@@ skipping 11 matching lines @@
     return PROCESS_NOTIFIED;
   }
 
   NOTREACHED() << "The other process returned unknown message: " << buf;
   return PROCESS_NOTIFIED;
 }
 
 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessOrCreate() {
   return NotifyOtherProcessWithTimeoutOrCreate(
       *CommandLine::ForCurrentProcess(),
-      kTimeoutInSeconds);
+      kRetryAttempts,
+      base::TimeDelta::FromSeconds(kTimeoutInSeconds));
 }
 
 ProcessSingleton::NotifyResult
 ProcessSingleton::NotifyOtherProcessWithTimeoutOrCreate(
     const CommandLine& command_line,
-    int timeout_seconds) {
-  NotifyResult result = NotifyOtherProcessWithTimeout(command_line,
-                                                      timeout_seconds, true);
+    int retry_attempts,
+    const base::TimeDelta& timeout_interval) {
+  NotifyResult result = NotifyOtherProcessWithTimeout(
+      command_line, retry_attempts, timeout_interval, true);
   if (result != PROCESS_NONE)
     return result;
   if (Create())
     return PROCESS_NONE;
   // If the Create() failed, try again to notify. (It could be that another
   // instance was starting at the same time and managed to grab the lock before
   // we did.)
   // This time, we don't want to kill anything if we aren't successful, since we
   // aren't going to try to take over the lock ourselves.
-  result = NotifyOtherProcessWithTimeout(command_line, timeout_seconds, false);
+  result = NotifyOtherProcessWithTimeout(
+      command_line, retry_attempts, timeout_interval, false);
   if (result != PROCESS_NONE)
     return result;
 
   return LOCK_ERROR;
 }
 
 void ProcessSingleton::OverrideCurrentPidForTesting(base::ProcessId pid) {
   current_pid_ = pid;
 }
 
@@ skipping 134 matching lines @@
 }
 
 void ProcessSingleton::KillProcess(int pid) {
   // TODO(james.su@gmail.com): Is SIGKILL ok?
   int rv = kill(static_cast<base::ProcessHandle>(pid), SIGKILL);
   // ESRCH = No Such Process (can happen if the other process is already in
   // progress of shutting down and finishes before we try to kill it).
   DCHECK(rv == 0 || errno == ESRCH) << "Error killing process: "
                                     << safe_strerror(errno);
 }