Refactor ProcessSingleton so that it may be used distinctly from a full browser process.

chrome/browser/process_singleton_linux_uitest.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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 <sys/types.h>
 #include <sys/wait.h>
 #include <signal.h>
 #include <unistd.h>
 #include <vector>
 #include <string>
 
+#include "base/bind.h"
+#include "base/command_line.h"
 #include "base/eintr_wrapper.h"
+#include "base/file_path.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/chrome_process_util.h"
 #include "chrome/test/ui/ui_test.h"
 #include "net/base/net_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
+bool UnexpectedNotificationCallback(const CommandLine& command_line,
+                                    const FilePath& current_directory) {
+  ADD_FAILURE() << "This callback should never be invoked because the active "
+                << "ProcessSingleton is that of the Browser process hosted by "
+                << "UITest.";
+  return false;
+}
+
 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() {
@@ skipping 47 matching lines @@
 }
 
 // A helper method to call ProcessSingleton::NotifyOtherProcessOrCreate().
 // |url| will be added to CommandLine for current process, so that it can be
 // sent to browser process by ProcessSingleton::NotifyOtherProcessOrCreate().
 ProcessSingleton::NotifyResult NotifyOtherProcessOrCreate(
     const std::string& url,
     int timeout_ms) {
   scoped_ptr<ProcessSingleton> process_singleton(CreateProcessSingleton());
   return process_singleton->NotifyOtherProcessWithTimeoutOrCreate(
-      CommandLineForUrl(url), timeout_ms / 1000);
+      CommandLineForUrl(url),
+      base::Bind(&UnexpectedNotificationCallback),
+      timeout_ms / 1000);
 }
 
 }  // 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.
 // This test is flaky as per http://crbug.com/74554.
 TEST_F(ProcessSingletonLinuxTest, DISABLED_CheckSocketFile) {
   struct stat statbuf;
@@ skipping 156 matching lines @@
   std::string url("about:blank");
   EXPECT_EQ(ProcessSingleton::PROFILE_IN_USE,
             NotifyOtherProcessOrCreate(url, TestTimeouts::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());
+  EXPECT_FALSE(process_singleton->Create(
+      base::Bind(&UnexpectedNotificationCallback)));
 }
 
 // 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());
+  EXPECT_FALSE(process_singleton->Create(
+      base::Bind(&UnexpectedNotificationCallback)));
 }
 
 // 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, TestTimeouts::action_timeout_ms()));
 }