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

chrome/browser/process_singleton_mac_unittest.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 <errno.h>
 #include <fcntl.h>
 #include <sys/file.h>
 
 #include "chrome/browser/process_singleton.h"
 
@@ skipping 51 matching lines @@
   }
 
   ScopedTempDir temp_dir_;
   FilePath lock_path_;
 };
 
 // Test that the base case doesn't blow up.
 TEST_F(ProcessSingletonMacTest, Basic) {
   ProcessSingleton ps(temp_dir_.path());
   EXPECT_FALSE(IsLocked());
-  EXPECT_TRUE(ps.Create());
+  EXPECT_TRUE(ps.Create(ProcessSingleton::NotificationCallback()));
   EXPECT_TRUE(IsLocked());
   ps.Cleanup();
   EXPECT_FALSE(IsLocked());
 }
 
 // The destructor should release the lock.
 TEST_F(ProcessSingletonMacTest, DestructorReleases) {
   EXPECT_FALSE(IsLocked());
   {
     ProcessSingleton ps(temp_dir_.path());
-    EXPECT_TRUE(ps.Create());
+    EXPECT_TRUE(ps.Create(ProcessSingleton::NotificationCallback()));
     EXPECT_TRUE(IsLocked());
   }
   EXPECT_FALSE(IsLocked());
 }
 
 // Multiple singletons should interlock appropriately.
 TEST_F(ProcessSingletonMacTest, Interlock) {
   ProcessSingleton ps1(temp_dir_.path());
   ProcessSingleton ps2(temp_dir_.path());
 
   // Windows and Linux use a command-line flag to suppress this, but
   // it is on a sub-process so the scope is contained.  Rather than
   // add additional API to process_singleton.h in an #ifdef, just tell
   // the reader what to expect and move on.
   LOG(ERROR) << "Expect two failures to obtain the lock.";
 
   // When |ps1| has the lock, |ps2| cannot get it.
   EXPECT_FALSE(IsLocked());
-  EXPECT_TRUE(ps1.Create());
+  EXPECT_TRUE(ps1.Create(ProcessSingleton::NotificationCallback()));
   EXPECT_TRUE(IsLocked());
-  EXPECT_FALSE(ps2.Create());
+  EXPECT_FALSE(ps2.Create(ProcessSingleton::NotificationCallback()));
   ps1.Cleanup();
 
   // And when |ps2| has the lock, |ps1| cannot get it.
   EXPECT_FALSE(IsLocked());
-  EXPECT_TRUE(ps2.Create());
+  EXPECT_TRUE(ps2.Create(ProcessSingleton::NotificationCallback()));
   EXPECT_TRUE(IsLocked());
-  EXPECT_FALSE(ps1.Create());
+  EXPECT_FALSE(ps1.Create(ProcessSingleton::NotificationCallback()));
   ps2.Cleanup();
   EXPECT_FALSE(IsLocked());
 }
 
 // Like |Interlock| test, but via |NotifyOtherProcessOrCreate()|.
 TEST_F(ProcessSingletonMacTest, NotifyOtherProcessOrCreate) {
   ProcessSingleton ps1(temp_dir_.path());
   ProcessSingleton ps2(temp_dir_.path());
 
   // Windows and Linux use a command-line flag to suppress this, but
   // it is on a sub-process so the scope is contained.  Rather than
   // add additional API to process_singleton.h in an #ifdef, just tell
   // the reader what to expect and move on.
   LOG(ERROR) << "Expect two failures to obtain the lock.";
 
   // When |ps1| has the lock, |ps2| cannot get it.
   EXPECT_FALSE(IsLocked());
-  EXPECT_EQ(ProcessSingleton::PROCESS_NONE, ps1.NotifyOtherProcessOrCreate());
+  EXPECT_EQ(
+      ProcessSingleton::PROCESS_NONE,
+      ps1.NotifyOtherProcessOrCreate(ProcessSingleton::NotificationCallback()));
   EXPECT_TRUE(IsLocked());
-  EXPECT_EQ(ProcessSingleton::PROFILE_IN_USE, ps2.NotifyOtherProcessOrCreate());
+  EXPECT_EQ(
+      ProcessSingleton::PROFILE_IN_USE,
+      ps2.NotifyOtherProcessOrCreate(ProcessSingleton::NotificationCallback()));
   ps1.Cleanup();
 
   // And when |ps2| has the lock, |ps1| cannot get it.
   EXPECT_FALSE(IsLocked());
-  EXPECT_EQ(ProcessSingleton::PROCESS_NONE, ps2.NotifyOtherProcessOrCreate());
+  EXPECT_EQ(
+      ProcessSingleton::PROCESS_NONE,
+      ps2.NotifyOtherProcessOrCreate(ProcessSingleton::NotificationCallback()));
   EXPECT_TRUE(IsLocked());
-  EXPECT_EQ(ProcessSingleton::PROFILE_IN_USE, ps1.NotifyOtherProcessOrCreate());
+  EXPECT_EQ(
+      ProcessSingleton::PROFILE_IN_USE,
+      ps1.NotifyOtherProcessOrCreate(ProcessSingleton::NotificationCallback()));
   ps2.Cleanup();
   EXPECT_FALSE(IsLocked());
 }
 
 // TODO(shess): Test that the lock is released when the process dies.
 // DEATH_TEST?  I don't know.  If the code to communicate between
 // browser processes is ever written, this all would need to be tested
 // more like the other platforms, in which case it would be easy.
 
 }  // namespace