Fix not deleting a lockfile or not killing a frozen browser on hostname change

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 104 matching lines @@
 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 = '-';
 
 bool g_disable_prompt = false;
 bool g_skip_is_chrome_process_check = false;
+bool g_user_opted_unlock_in_use_profile = false;
 
 // Set the close-on-exec bit on a file descriptor.
 // Returns 0 on success, -1 on failure.
 int SetCloseOnExec(int fd) {
   int flags = fcntl(fd, F_GETFD, 0);
   if (-1 == flags)
     return flags;
   if (flags & FD_CLOEXEC)
     return 0;
   return fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
@@ skipping 180 matching lines @@
 bool DisplayProfileInUseError(const base::FilePath& lock_path,
                               const std::string& hostname,
                               int pid) {
   base::string16 error = l10n_util::GetStringFUTF16(
       IDS_PROFILE_IN_USE_POSIX,
       base::IntToString16(pid),
       base::ASCIIToUTF16(hostname));
   LOG(ERROR) << error;
 
   if (g_disable_prompt)
-    return false;
+    return g_user_opted_unlock_in_use_profile;
 
 #if defined(OS_LINUX)
   base::string16 relaunch_button_text = l10n_util::GetStringUTF16(
       IDS_PROFILE_IN_USE_LINUX_RELAUNCH);
   return ShowProcessSingletonDialog(error, relaunch_button_text);
 #elif defined(OS_MACOSX)
   // On Mac, always usurp the lock.
   return true;
 #endif
 
   NOTREACHED();
   return false;
 }
 
 bool IsChromeProcess(pid_t pid) {
+  if (g_skip_is_chrome_process_check)
+    return true;
+
   base::FilePath other_chrome_path(base::GetProcessExecutablePath(pid));
   return (!other_chrome_path.empty() &&
-          (g_skip_is_chrome_process_check ||
-           other_chrome_path.BaseName() ==
-               base::FilePath(chrome::kBrowserProcessExecutableName)));
+          other_chrome_path.BaseName() ==
+              base::FilePath(chrome::kBrowserProcessExecutableName));
 }
 
 // A helper class to hold onto a socket.
 class ScopedSocket {
  public:
   ScopedSocket() : fd_(-1) { Reset(); }
   ~ScopedSocket() { Close(); }
   int fd() { return fd_; }
   void Reset() {
     Close();
@@ skipping 462 matching lines @@
     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_);
       SendRemoteProcessInteractionResultHistogram(SAME_BROWSER_INSTANCE);
       return PROCESS_NONE;
     }
 
     if (retries == retry_attempts) {
       // Retries failed.  Kill the unresponsive chrome process and continue.
-      if (!kill_unresponsive || !KillProcessByLockPath())
+      if (!kill_unresponsive || !KillProcessByLockPath(false))
         return PROFILE_IN_USE;
       SendRemoteHungProcessTerminateReasonHistogram(NOTIFY_ATTEMPTS_EXCEEDED);
       return PROCESS_NONE;
     }
 
     base::PlatformThread::Sleep(sleep_interval);
   }
 
   timeval socket_timeout = TimeDeltaToTimeVal(timeout);
   setsockopt(socket.fd(),
@@ skipping 15 matching lines @@
   const std::vector<std::string>& argv = cmd_line.argv();
   for (std::vector<std::string>::const_iterator it = argv.begin();
       it != argv.end(); ++it) {
     to_send.push_back(kTokenDelimiter);
     to_send.append(*it);
   }
 
   // Send the message
   if (!WriteToSocket(socket.fd(), to_send.data(), to_send.length())) {
     // Try to kill the other process, because it might have been dead.
-    if (!kill_unresponsive || !KillProcessByLockPath())
+    if (!kill_unresponsive || !KillProcessByLockPath(true))
       return PROFILE_IN_USE;
     SendRemoteHungProcessTerminateReasonHistogram(SOCKET_WRITE_FAILED);
     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);
 
   // Failed to read ACK, the other process might have been frozen.
   if (len <= 0) {
-    if (!kill_unresponsive || !KillProcessByLockPath())
+    if (!kill_unresponsive || !KillProcessByLockPath(true))
       return PROFILE_IN_USE;
     SendRemoteHungProcessTerminateReasonHistogram(SOCKET_READ_FAILED);
     return PROCESS_NONE;
   }
 
   buf[len] = '\0';
   if (strncmp(buf, kShutdownToken, arraysize(kShutdownToken) - 1) == 0) {
     // The other process is shutting down, it's safe to start a new process.
     SendRemoteProcessInteractionResultHistogram(REMOTE_PROCESS_SHUTTING_DOWN);
     return PROCESS_NONE;
@@ skipping 68 matching lines @@
 
 void ProcessSingleton::OverrideCurrentPidForTesting(base::ProcessId pid) {
   current_pid_ = pid;
 }
 
 void ProcessSingleton::OverrideKillCallbackForTesting(
     const base::Callback<void(int)>& callback) {
   kill_callback_ = callback;
 }
 
+// static
 void ProcessSingleton::DisablePromptForTesting() {
   g_disable_prompt = true;
 }
 
+// static
 void ProcessSingleton::SkipIsChromeProcessCheckForTesting(bool skip) {
   g_skip_is_chrome_process_check = skip;
 }
 
+// static
+void ProcessSingleton::SetUserOptedUnlockInUseProfileForTesting(
+    bool set_unlock) {
+  g_user_opted_unlock_in_use_profile = set_unlock;
+}
+
 bool ProcessSingleton::Create() {
   int sock;
   sockaddr_un addr;
 
   // The symlink lock is pointed to the hostname and process id, so other
   // processes can find it out.
   base::FilePath symlink_content(base::StringPrintf(
       "%s%c%u",
       net::GetHostName().c_str(),
       kLockDelimiter,
@@ skipping 86 matching lines @@
   while (pid != cur_pid) {
     pid = base::GetParentProcessId(pid);
     if (pid < 0)
       return false;
     if (!IsChromeProcess(pid))
       return false;
   }
   return true;
 }
 
-bool ProcessSingleton::KillProcessByLockPath() {
+bool ProcessSingleton::KillProcessByLockPath(bool is_connected_to_socket) {
   std::string hostname;
   int pid;
   ParseLockPath(lock_path_, &hostname, &pid);
 
-  if (!hostname.empty() && hostname != net::GetHostName()) {
+  if (!hostname.empty() && hostname != net::GetHostName() &&
+      !is_connected_to_socket) {
     bool res = DisplayProfileInUseError(lock_path_, hostname, pid);
-    if (res)
+    if (res) {
+      UnlinkPath(lock_path_);
       SendRemoteProcessInteractionResultHistogram(PROFILE_UNLOCKED_BEFORE_KILL);
+    }
     return res;
   }
   UnlinkPath(lock_path_);
 
   if (IsSameChromeInstance(pid)) {
     SendRemoteProcessInteractionResultHistogram(
         SAME_BROWSER_INSTANCE_BEFORE_KILL);
     return true;
   }
 
@@ skipping 29 matching lines @@
       case EPERM:
         action = TERMINATE_NOT_ENOUGH_PERMISSIONS;
         break;
       default:
         action = TERMINATE_FAILED;
         break;
     }
   }
   SendRemoteProcessInteractionResultHistogram(action);
 }