Move the SingletonSocket to a temporary directory

chrome/browser/process_singleton_linux_uitest.cc

 // Copyright (c) 2010 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 <sys/types.h>
 #include <sys/wait.h>
 #include <signal.h>
 #include <unistd.h>
@@ skipping 17 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 class ProcessSingletonLinuxTest : public UITest {
  public:
   virtual void SetUp() {
     UITest::SetUp();
     lock_path_ = user_data_dir().Append(chrome::kSingletonLockFilename);
     socket_path_ = user_data_dir().Append(chrome::kSingletonSocketFilename);
+    cookie_path_ = user_data_dir().Append(chrome::kSingletonCookieFilename);
   }
 
   virtual void TearDown() {
     UITest::TearDown();
 
     // Check that the test cleaned up after itself.
     struct stat statbuf;
     bool lock_exists = lstat(lock_path_.value().c_str(), &statbuf) == 0;
     EXPECT_FALSE(lock_exists);
 
     if (lock_exists) {
       // Unlink to prevent failing future tests if the lock still exists.
       EXPECT_EQ(unlink(lock_path_.value().c_str()), 0);
     }
   }
 
   FilePath lock_path_;
   FilePath socket_path_;
+  FilePath cookie_path_;
 };
 
 ProcessSingleton* CreateProcessSingleton() {
   FilePath user_data_dir;
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
 
   return new ProcessSingleton(user_data_dir);
 }
 
 CommandLine CommandLineForUrl(const std::string& url) {
@@ skipping 33 matching lines @@
 
 }  // namespace
 
 // Test if the socket file and symbol link created by ProcessSingletonLinux
 // are valid. When running this test, the ProcessSingleton object is already
 // initiated by UITest. So we just test against this existing object.
 TEST_F(ProcessSingletonLinuxTest, CheckSocketFile) {
   struct stat statbuf;
   ASSERT_EQ(0, lstat(lock_path_.value().c_str(), &statbuf));
   ASSERT_TRUE(S_ISLNK(statbuf.st_mode));
-  char buf[PATH_MAX + 1];
+  char buf[PATH_MAX];
   ssize_t len = readlink(lock_path_.value().c_str(), buf, PATH_MAX);
   ASSERT_GT(len, 0);
-  buf[len] = '\0';
 
   ASSERT_EQ(0, lstat(socket_path_.value().c_str(), &statbuf));
+  ASSERT_TRUE(S_ISLNK(statbuf.st_mode));
+
+  len = readlink(socket_path_.value().c_str(), buf, PATH_MAX);
+  ASSERT_GT(len, 0);
+  FilePath socket_target_path = FilePath(std::string(buf, len));
+
+  ASSERT_EQ(0, lstat(socket_target_path.value().c_str(), &statbuf));
   ASSERT_TRUE(S_ISSOCK(statbuf.st_mode));
+
+  len = readlink(cookie_path_.value().c_str(), buf, PATH_MAX);
+  ASSERT_GT(len, 0);
+  std::string cookie(buf, len);
+
+  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));
 }
 
 #if defined(OS_LINUX) && defined(TOOLKIT_VIEWS)
 // The following tests in linux/view does not pass without a window manager,
 // which is true in build/try bots.
 // See http://crbug.com/30953.
 #define NotifyOtherProcessSuccess FAILS_NotifyOtherProcessSuccess
 #define NotifyOtherProcessHostChanged FAILS_NotifyOtherProcessHostChanged
 #endif
 
@@ skipping 114 matching lines @@
             NotifyOtherProcessOrCreate(url, action_timeout_ms()));
 
   ASSERT_EQ(0, unlink(lock_path_.value().c_str()));
 }
 
 // Test that Create fails when another browser is using the profile directory.
 TEST_F(ProcessSingletonLinuxTest, CreateFailsWithExistingBrowser) {
   scoped_ptr<ProcessSingleton> process_singleton(CreateProcessSingleton());
   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) {
+  scoped_ptr<ProcessSingleton> process_singleton(CreateProcessSingleton());
+
+  // 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);
+  FilePath socket_target_path = 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) {
+  // 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, action_timeout_ms()));
+}