Use process_singleton_linux on Mac.

chrome/browser/process_singleton_posix.cc

 // Copyright (c) 2012 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 56 matching lines @@
 #include "base/sequenced_task_runner_helpers.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
-#include "chrome/browser/ui/process_singleton_dialog_linux.h"
 #include "chrome/common/chrome_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "net/base/net_util.h"
 #include "ui/base/l10n/l10n_util.h"
 
+#if defined(OS_LINUX)
+#include "chrome/browser/ui/process_singleton_dialog_linux.h"
+#endif
+
 #if defined(TOOLKIT_GTK)
 #include <gdk/gdk.h>
 #endif
 #if defined(TOOLKIT_VIEWS) && !defined(OS_CHROMEOS)
 #include "ui/views/linux_ui/linux_ui.h"
 #endif
 
 using content::BrowserThread;
 
 const int ProcessSingleton::kTimeoutInSeconds;
@@ skipping 199 matching lines @@
     *pid = -1;
 
   return true;
 }
 
 // Returns true if the user opted to unlock the profile.
 bool DisplayProfileInUseError(const base::FilePath& lock_path,
                               const std::string& hostname,
                               int pid) {
   base::string16 error = l10n_util::GetStringFUTF16(
-      IDS_PROFILE_IN_USE_LINUX,
+      IDS_PROFILE_IN_USE_POSIX,
       base::IntToString16(pid),
       base::ASCIIToUTF16(hostname));
+  LOG(ERROR) << base::SysWideToNativeMB(base::UTF16ToWide(error)).c_str();
+  if (!g_disable_prompt) {
+#if defined(OS_LINUX)
   base::string16 relaunch_button_text = l10n_util::GetStringUTF16(
       IDS_PROFILE_IN_USE_LINUX_RELAUNCH);
-  LOG(ERROR) << base::SysWideToNativeMB(base::UTF16ToWide(error)).c_str();
-  if (!g_disable_prompt)
-    return ShowProcessSingletonDialog(error, relaunch_button_text);
+  return ShowProcessSingletonDialog(error, relaunch_button_text);

[tapted, 2014/04/08 17:56:44]

Does this need an implementation on mac as well? I guess a log message is not so
different to what users get now.. but does the linux singleton have the same
assurance/recovery for a dangling profile lock?

That is, currently there's a good guarantee on mac that Force-Quitting Chrome
will make the 'Unable to obtain profile lock' error go away. Is there any flow
where that could leave a dangling lock, requiring user intervention? (like, user
connects to a different network and their hostname changes, causing the logic to
think an old process is on a different computer and not auto-kill the currently
running (or dead) process?)

Also, what's an example string you get on Mac?

[jackhou1, 2014/04/14 04:12:10]

It's actually less common than what users get now. At the moment, a log message
occurs whenever you start another chrome process with the same UDD. After this
change, that case will just work. The message here only occurs if the existing
process is not running on the same host.
 
Interesting, I think this case could happen on linux too, except it would let
the user decide to usurp the lock. I wonder if we could use something more
constant than hostname instead?
From the unit test:
The profile appears to be in use by another Chromium process (1234) on another
computer (FAKEFOOHOST). Chromium has locked the profile so that it doesn't get
corrupted. If you are sure no other processes are using this profile, you can
unlock the profile and relaunch Chromium.

[mattm, 2014/04/17 21:44:54]

I'm not sure about osx, but linux doesn't normally change the hostname on a
network change.

+#endif
+  }
   return false;
 }
 
 bool IsChromeProcess(pid_t pid) {
   base::FilePath other_chrome_path(base::GetProcessExecutablePath(pid));
   return (!other_chrome_path.empty() &&
           other_chrome_path.BaseName() ==
           base::FilePath(chrome::kBrowserProcessExecutableName));

[tapted, 2014/04/08 17:56:44]

This might not work on mac? -- chrome::kBrowserProcessExecutableName is the
official release name. Mac uses different names for Chromium/Official (whereas
on linux they are both 'chrome.exe'). Do you need to check for
kBrowserProcessExecutableNameChromium in some cases?

[jackhou1, 2014/04/14 04:12:10]

chrome::kBrowserProcessExecutableName seems to be "Chromium" on Mac. I think
kBrowserProcessExecutableNameChromium is used when you want to refer to
"Chromium" from an official build.

 }
 
 // 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 655 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);
 }