linux: expose the ProcessSingleton timeout to speed tests

chrome/browser/process_singleton_linux.cc

 // Copyright (c) 2009 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 609 matching lines @@
       foreground_window_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(watcher_(new LinuxWatcher(this))) {
   socket_path_ = user_data_dir.Append(chrome::kSingletonSocketFilename);
   lock_path_ = user_data_dir.Append(chrome::kSingletonLockFilename);
 }
 
 ProcessSingleton::~ProcessSingleton() {
 }
 
 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() {
+  return NotifyOtherProcessWithTimeout(kTimeoutInSeconds /* seconds */);

[Paweł Hajdan Jr., 2009/09/17 19:45:56]

nit: Is this /* seconds */ comment necessary? The constant itself ends with
Seconds...

[Evan Martin, 2009/09/17 20:37:13]

Good catch.  It was leftover from before I had noticed kTimeoutInSeconds existed
(you can see in the code below it used to have '20' hardcoded).

+}
+
+ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessWithTimeout(
+    int timeout_seconds) {
   int socket;
   sockaddr_un addr;
   SetupSocket(socket_path_.value(), &socket, &addr);
 
   // It'll close the socket automatically when exiting this method.
   SocketCloser socket_closer(socket);
 
   // Connecting to the socket
   int ret = HANDLE_EINTR(connect(socket,
                                  reinterpret_cast<sockaddr*>(&addr),
                                  sizeof(addr)));
   if (ret < 0) {
     // TODO(mattm): there is a bit of a race here if another instance on the
     // same host is in Create() and has created the lock but not attached to the
     // socket.  Our CheckLockHostnameAndCleanup call will clean up their lock
     // and allow us to create a new one.
     if (!CheckLockHostnameAndCleanup(lock_path_.value()))
       return PROFILE_IN_USE;
     return PROCESS_NONE;  // Tell the caller there's nobody to notify.
   }
 
-  timeval timeout = {20, 0};
+  timeval timeout = {timeout_seconds, 0};
   setsockopt(socket, 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);
 
   FilePath current_dir;
   if (!PathService::Get(base::DIR_CURRENT, &current_dir))
     return PROCESS_NONE;
@@ skipping 15 matching lines @@
     return PROCESS_NONE;
   }
 
   if (shutdown(socket, SHUT_WR) < 0)
     LOG(ERROR) << "shutdown() failed: " << strerror(errno);
 
   // 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, buf, kMaxACKMessageLength, kTimeoutInSeconds);
+      ReadFromSocket(socket, buf, kMaxACKMessageLength, timeout_seconds);
 
   // Failed to read ACK, the other process might have been frozen.
   if (len <= 0) {
     if (!KillProcessByLockPath(lock_path_.value()))
       return PROFILE_IN_USE;
     return PROCESS_NONE;
   }
 
   buf[len] = '\0';
   if (strncmp(buf, kShutdownToken, arraysize(kShutdownToken) - 1) == 0) {
@@ skipping 60 matching lines @@
   DCHECK(ml);
   ml->PostTask(FROM_HERE, NewRunnableMethod(
     watcher_.get(),
     &ProcessSingleton::LinuxWatcher::StartListening,
     sock));
 }
 
 void ProcessSingleton::Cleanup() {
   UnlinkPath(lock_path_.value());
 }