Use process_singleton_linux on Mac.

chrome/browser/process_singleton_posix_unittest.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.
 
 #include "chrome/browser/process_singleton.h"
 
+#include <fcntl.h>
 #include <signal.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
+#include "base/posix/eintr_wrapper.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/test/thread_test_helper.h"
 #include "base/threading/thread.h"
 #include "chrome/common/chrome_constants.h"
 #include "content/public/test/test_browser_thread.h"
 #include "net/base/net_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 
 namespace {
 
-class ProcessSingletonLinuxTest : public testing::Test {
+class ProcessSingletonPosixTest : public testing::Test {
  public:
   // A ProcessSingleton exposing some protected methods for testing.
   class TestableProcessSingleton : public ProcessSingleton {
    public:
     explicit TestableProcessSingleton(const base::FilePath& user_data_dir)
         : ProcessSingleton(
             user_data_dir,
             base::Bind(&TestableProcessSingleton::NotificationCallback,
                        base::Unretained(this))) {}
 
 
     std::vector<CommandLine::StringVector> callback_command_lines_;
 
     using ProcessSingleton::NotifyOtherProcessWithTimeout;
     using ProcessSingleton::NotifyOtherProcessWithTimeoutOrCreate;
     using ProcessSingleton::OverrideCurrentPidForTesting;
     using ProcessSingleton::OverrideKillCallbackForTesting;
 
    private:
     bool NotificationCallback(const CommandLine& command_line,
                               const base::FilePath& current_directory) {
       callback_command_lines_.push_back(command_line.argv());
       return true;
     }
   };
 
-  ProcessSingletonLinuxTest()
+  ProcessSingletonPosixTest()
       : kill_callbacks_(0),
         io_thread_(BrowserThread::IO),
         wait_event_(true, false),
         signal_event_(true, false),
         process_singleton_on_thread_(NULL) {
     io_thread_.StartIOThread();
   }
 
   virtual void SetUp() {
     testing::Test::SetUp();
@@ skipping 10 matching lines @@
   virtual void TearDown() {
     scoped_refptr<base::ThreadTestHelper> io_helper(new base::ThreadTestHelper(
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO).get()));
     ASSERT_TRUE(io_helper->Run());
 
     // Destruct the ProcessSingleton object before the IO thread so that its
     // internals are destructed properly.
     if (process_singleton_on_thread_) {
       worker_thread_->message_loop()->PostTask(
           FROM_HERE,
-          base::Bind(&ProcessSingletonLinuxTest::DestructProcessSingleton,
+          base::Bind(&ProcessSingletonPosixTest::DestructProcessSingleton,
                      base::Unretained(this)));
 
       scoped_refptr<base::ThreadTestHelper> helper(new base::ThreadTestHelper(
           worker_thread_->message_loop_proxy().get()));
       ASSERT_TRUE(helper->Run());
     }
 
     io_thread_.Stop();
     testing::Test::TearDown();
   }
 
   void CreateProcessSingletonOnThread() {
     ASSERT_EQ(NULL, worker_thread_.get());
     worker_thread_.reset(new base::Thread("BlockingThread"));
     worker_thread_->Start();
 
     worker_thread_->message_loop()->PostTask(
        FROM_HERE,
-       base::Bind(&ProcessSingletonLinuxTest::
+       base::Bind(&ProcessSingletonPosixTest::
                       CreateProcessSingletonInternal,
                   base::Unretained(this)));
 
     scoped_refptr<base::ThreadTestHelper> helper(
         new base::ThreadTestHelper(worker_thread_->message_loop_proxy().get()));
     ASSERT_TRUE(helper->Run());
   }
 
   TestableProcessSingleton* CreateProcessSingleton() {
     return new TestableProcessSingleton(temp_dir_.path());
   }
 
   ProcessSingleton::NotifyResult NotifyOtherProcess(
       bool override_kill,
       base::TimeDelta timeout) {
     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(&ProcessSingletonLinuxTest::KillCallback,
+          base::Bind(&ProcessSingletonPosixTest::KillCallback,
                      base::Unretained(this)));
     }
 
     return process_singleton->NotifyOtherProcessWithTimeout(
         command_line, timeout.InSeconds(), true);
   }
 
   // A helper method to call ProcessSingleton::NotifyOtherProcessOrCreate().
   ProcessSingleton::NotifyResult NotifyOtherProcessOrCreate(
       const std::string& url,
@@ skipping 19 matching lines @@
         break;
       }
     }
     ASSERT_TRUE(found);
     ASSERT_EQ(0, kill_callbacks_);
   }
 
   void BlockWorkerThread() {
     worker_thread_->message_loop()->PostTask(
         FROM_HERE,
-        base::Bind(&ProcessSingletonLinuxTest::BlockThread,
+        base::Bind(&ProcessSingletonPosixTest::BlockThread,
                    base::Unretained(this)));
   }
 
   void UnblockWorkerThread() {
     wait_event_.Signal();  // Unblock the worker thread for shutdown.
     signal_event_.Wait();  // Ensure thread unblocks before continuing.
   }
 
   void BlockThread() {
     wait_event_.Wait();
@@ skipping 26 matching lines @@
   base::ScopedTempDir temp_dir_;
   base::WaitableEvent wait_event_;
   base::WaitableEvent signal_event_;
 
   scoped_ptr<base::Thread> worker_thread_;
   TestableProcessSingleton* process_singleton_on_thread_;
 };
 
 }  // namespace
 
-// Test if the socket file and symbol link created by ProcessSingletonLinux
+// Test if the socket file and symbol link created by ProcessSingletonPosix
 // are valid.
 // If this test flakes, use http://crbug.com/74554.
-TEST_F(ProcessSingletonLinuxTest, CheckSocketFile) {
+TEST_F(ProcessSingletonPosixTest, CheckSocketFile) {
   CreateProcessSingletonOnThread();
   struct stat statbuf;
   ASSERT_EQ(0, lstat(lock_path_.value().c_str(), &statbuf));
   ASSERT_TRUE(S_ISLNK(statbuf.st_mode));
   char buf[PATH_MAX];
   ssize_t len = readlink(lock_path_.value().c_str(), buf, PATH_MAX);
   ASSERT_GT(len, 0);
 
   ASSERT_EQ(0, lstat(socket_path_.value().c_str(), &statbuf));
   ASSERT_TRUE(S_ISLNK(statbuf.st_mode));
@@ skipping 11 matching lines @@
 
   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));
 }
 
 // TODO(james.su@gmail.com): port following tests to Windows.
 // Test success case of NotifyOtherProcess().
-TEST_F(ProcessSingletonLinuxTest, NotifyOtherProcessSuccess) {
+TEST_F(ProcessSingletonPosixTest, NotifyOtherProcessSuccess) {
   CreateProcessSingletonOnThread();
   EXPECT_EQ(ProcessSingleton::PROCESS_NOTIFIED,
             NotifyOtherProcess(true, TestTimeouts::action_timeout()));
   CheckNotified();
 }
 
 // Test failure case of NotifyOtherProcess().
-TEST_F(ProcessSingletonLinuxTest, NotifyOtherProcessFailure) {
+TEST_F(ProcessSingletonPosixTest, NotifyOtherProcessFailure) {
   CreateProcessSingletonOnThread();
 
   BlockWorkerThread();
   EXPECT_EQ(ProcessSingleton::PROCESS_NONE,
             NotifyOtherProcess(true, TestTimeouts::action_timeout()));
 
   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(ProcessSingletonLinuxTest, NotifyOtherProcessNoSuicide) {
+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()));
   // 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(ProcessSingletonLinuxTest, NotifyOtherProcessHostChanged) {
+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()));
   CheckNotified();
 }
 
 // Test that we fail when lock says process is on another host and we can't
 // notify it over the socket.
-TEST_F(ProcessSingletonLinuxTest, 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()));
 
   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.
-TEST_F(ProcessSingletonLinuxTest, 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()));
 
   ASSERT_EQ(0, unlink(lock_path_.value().c_str()));
 
   UnblockWorkerThread();
 }
 
 // Test that Create fails when another browser is using the profile directory.
-TEST_F(ProcessSingletonLinuxTest, CreateFailsWithExistingBrowser) {
+TEST_F(ProcessSingletonPosixTest, CreateFailsWithExistingBrowser) {
   CreateProcessSingletonOnThread();
 
   scoped_ptr<TestableProcessSingleton> process_singleton(
       CreateProcessSingleton());
   process_singleton->OverrideCurrentPidForTesting(base::GetCurrentProcId() + 1);
   EXPECT_FALSE(process_singleton->Create());
 }
 
 // Test that Create fails when another browser is using the profile directory
 // but with the old socket location.
-TEST_F(ProcessSingletonLinuxTest, CreateChecksCompatibilitySocket) {
+TEST_F(ProcessSingletonPosixTest, CreateChecksCompatibilitySocket) {
   CreateProcessSingletonOnThread();
   scoped_ptr<TestableProcessSingleton> process_singleton(
       CreateProcessSingleton());
   process_singleton->OverrideCurrentPidForTesting(base::GetCurrentProcId() + 1);
 
   // Do some surgery so as to look like the old configuration.
   char buf[PATH_MAX];
   ssize_t len = readlink(socket_path_.value().c_str(), buf, sizeof(buf));
   ASSERT_GT(len, 0);
   base::FilePath socket_target_path = base::FilePath(std::string(buf, len));
   ASSERT_EQ(0, unlink(socket_path_.value().c_str()));
   ASSERT_EQ(0, rename(socket_target_path.value().c_str(),
                       socket_path_.value().c_str()));
   ASSERT_EQ(0, unlink(cookie_path_.value().c_str()));
 
   EXPECT_FALSE(process_singleton->Create());
 }
 
 // Test that we fail when lock says process is on another host and we can't
 // notify it over the socket before of a bad cookie.
-TEST_F(ProcessSingletonLinuxTest, NotifyOtherProcessOrCreate_BadCookie) {
+TEST_F(ProcessSingletonPosixTest, NotifyOtherProcessOrCreate_BadCookie) {
   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()));
 }
 
+#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());
+  int lock_fd = HANDLE_EINTR(open(lock_path_.value().c_str(),
+                                  O_RDWR | O_CREAT | O_EXLOCK, 0644));
+  ASSERT_NE(-1, lock_fd);
+  EXPECT_FALSE(process_singleton->Create());

[mattm, 2014/04/24 22:58:51]

maybe also double check that after that the lockpath still exists and still is a
normal file

[jackhou1, 2014/04/28 05:20:16]

Done.

+}
+
+// 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());
+  EXPECT_TRUE(base::IsLink(lock_path_));
+}
+#endif  // defined(OS_MACOSX)