Move many ProcessSingleton methods to "protected" visibility as an upcoming refactoring of ProcessS…

chrome/browser/process_singleton_linux_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 <signal.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
@@ skipping 21 matching lines @@
 
 namespace {
 
 bool NotificationCallback(const CommandLine& command_line,
                           const FilePath& current_directory) {
   return true;
 }
 
 class ProcessSingletonLinuxTest : public testing::Test {
  public:
+  // A MockPocessSingleton to test protected methods of ProcessSingleton.
+  class MockProcessSingleton : ProcessSingleton {
+   public:
+    virtual NotifyResult NotifyOtherProcess() OVERRIDE {
+      ProcessSingleton::NotifyOtherProcess();
+    }
+    virtual bool Create(
+        const NotificationCallback& notification_callback) OVERRIDE {
+      ProcessSingleton::Create();
+    }
+    virtual NotifyResult NotifyOtherProcessWithTimeout(
+        const CommandLine& command_line,
+        int timeout_seconds,
+        bool kill_unresponsive) OVERRIDE {
+      ProcessSingleton::NotifyOtherProcessWithTimeout(
+          command_line, timeout_seconds, kill_unresponsive);
+    }
+    virtual NotifyResult NotifyOtherProcessWithTimeoutOrCreate(
+        const CommandLine& command_line,
+        const NotificationCallback& notification_callback,
+        int timeout_seconds) OVERRIDE {
+      ProcessSingleton::NotifyOtherProcessWithTimeoutOrCreate(
+          command_line, notification_callback, timeout_seconds);
+    }
+    virtual void OverrideCurrentPidForTesting(base::ProcessId pid) OVERRIDE {
+      ProcessSingleton::OverrideCurrentPidForTesting(pid);
+    }
+    virtual void OverrideKillCallbackForTesting(
+        const base::Callback<void(int)>& callback) OVERRIDE {
+      ProcessSingleton::OverrideKillCallbackForTesting(callback);
+    }
+  };
+
   ProcessSingletonLinuxTest()
       : 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() {
@@ skipping 40 matching lines @@
        base::Bind(&ProcessSingletonLinuxTest::
                       CreateProcessSingletonInternal,
                   base::Unretained(this)));
 
     scoped_refptr<base::ThreadTestHelper> helper(
         new base::ThreadTestHelper(
             worker_thread_->message_loop_proxy()));
     ASSERT_TRUE(helper->Run());
   }
 
-  ProcessSingleton* CreateProcessSingleton() {
-    return new ProcessSingleton(temp_dir_.path());
+  MockProcessSingleton* CreateProcessSingleton() {
+    return new MockProcessSingleton(temp_dir_.path());
   }
 
   ProcessSingleton::NotifyResult NotifyOtherProcess(
       bool override_kill,
       base::TimeDelta timeout) {
-    scoped_ptr<ProcessSingleton> process_singleton(CreateProcessSingleton());
+    scoped_ptr<MockProcessSingleton> 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::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,
       base::TimeDelta timeout) {
-    scoped_ptr<ProcessSingleton> process_singleton(CreateProcessSingleton());
+    scoped_ptr<MockProcessSingleton> process_singleton(
+        CreateProcessSingleton());
     CommandLine command_line(CommandLine::ForCurrentProcess()->GetProgram());
     command_line.AppendArg(url);
     return process_singleton->NotifyOtherProcessWithTimeoutOrCreate(
         command_line, base::Bind(&NotificationCallback), timeout.InSeconds());
   }
 
   void CheckNotified() {
     ASSERT_EQ(1u, callback_command_lines_.size());
     bool found = false;
     for (size_t i = 0; i < callback_command_lines_[0].size(); ++i) {
@@ skipping 52 matching lines @@
   void KillCallback(int pid) {
     kill_callbacks_++;
   }
 
   content::TestBrowserThread io_thread_;
   base::ScopedTempDir temp_dir_;
   base::WaitableEvent wait_event_;
   base::WaitableEvent signal_event_;
 
   scoped_ptr<base::Thread> worker_thread_;
-  ProcessSingleton* process_singleton_on_thread_;
+  MockProcessSingleton* process_singleton_on_thread_;
 
   std::vector<CommandLine::StringVector> callback_command_lines_;
 };
 
 }  // namespace
 
 // Test if the socket file and symbol link created by ProcessSingletonLinux
 // are valid.
 // If this test flakes, use http://crbug.com/74554.
 TEST_F(ProcessSingletonLinuxTest, CheckSocketFile) {
@@ skipping 114 matching lines @@
 
   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) {
   CreateProcessSingletonOnThread();
 
-  scoped_ptr<ProcessSingleton> process_singleton(CreateProcessSingleton());
+  scoped_ptr<MockProcessSingleton> process_singleton(CreateProcessSingleton());
   process_singleton->OverrideCurrentPidForTesting(base::GetCurrentProcId() + 1);
   EXPECT_FALSE(process_singleton->Create(
                base::Bind(&NotificationCallback)));
 }
 
 // Test that Create fails when another browser is using the profile directory
 // but with the old socket location.
 TEST_F(ProcessSingletonLinuxTest, CreateChecksCompatibilitySocket) {
   CreateProcessSingletonOnThread();
-  scoped_ptr<ProcessSingleton> process_singleton(CreateProcessSingleton());
+  scoped_ptr<MockProcessSingleton> 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);
   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()));
@@ skipping 12 matching lines @@
 
   // 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()));
 }