Multi process notifications on linux (dbus)

chrome/browser/multi_process_notification_unittest.cc

 // Copyright (c) 2011 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/multi_process_notification.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/test/multiprocess_test.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread.h"
 #include "base/time.h"
 #include "testing/multiprocess_func_list.h"
 
-#if defined(OS_MACOSX)
-// TODO(dmaclach): Remove defined(OS_MACOSX) once
-//                 MultiProcessNotification is implemented on Win/Linux.
+#if defined(OS_POSIX)
+// TODO(ajwong): Remove defined(OS_POSIX) restriction once
+//               MultiProcessNotification is implemented on Win.
 
 namespace {
 
 const char kStartedNotificationName[] = "MultiProcessTestStartedNotification";
 const char kQuitNotificationName[] = "MultiProcessTestQuitNotification";
 
 void SpinRunLoop(int milliseconds) {
   MessageLoop *loop = MessageLoop::current();
 
   // Post a quit task so that this loop eventually ends and we don't hang
@@ skipping 206 matching lines @@
     case multi_process_notification::SystemDomain:
       ASSERT_FALSE(profile_quitter.WasNotificationReceived());
       ASSERT_FALSE(user_quitter.WasNotificationReceived());
       ASSERT_TRUE(system_quitter.WasNotificationReceived());
       break;
   }
 }
 
 TEST_F(MultiProcessNotificationTest, BasicCreationTest) {
   QuitterDelegate quitter;
+  MessageLoop* message_loop = IOMessageLoop();
+
+  multi_process_notification::Listener profile_listener(
+      "BasicCreationTest", multi_process_notification::ProfileDomain, &quitter);
+  ASSERT_TRUE(profile_listener.Start(message_loop));
+  SpinRunLoop(TestTimeouts::action_max_timeout_ms());
+  ASSERT_TRUE(quitter.WasStartedReceived());
+
   multi_process_notification::Listener local_listener(
       "BasicCreationTest", multi_process_notification::UserDomain, &quitter);
-  MessageLoop* message_loop = IOMessageLoop();
   ASSERT_TRUE(local_listener.Start(message_loop));
   SpinRunLoop(TestTimeouts::action_max_timeout_ms());
   ASSERT_TRUE(quitter.WasStartedReceived());
+
   multi_process_notification::Listener system_listener(
       "BasicCreationTest", multi_process_notification::SystemDomain, &quitter);
   ASSERT_TRUE(system_listener.Start(message_loop));
   SpinRunLoop(TestTimeouts::action_max_timeout_ms());
   ASSERT_TRUE(quitter.WasStartedReceived());
+}
 
-  multi_process_notification::Listener local_listener2(
-      "BasicCreationTest", multi_process_notification::UserDomain, &quitter);
+TEST_F(MultiProcessNotificationTest, ListenOnNonIoThread) {
+  QuitterDelegate quitter;
+  multi_process_notification::Listener local_listener(
+      "ListenOnNonIoThread", multi_process_notification::UserDomain, &quitter);
   // Should fail because current message loop should not be an IOMessageLoop.
-  ASSERT_FALSE(local_listener2.Start(MessageLoop::current()));
+  ASSERT_FALSE(local_listener.Start(MessageLoop::current()));
 }
 
 TEST_F(MultiProcessNotificationTest, PostInProcessNotification) {
   std::string local_notification("QuitLocalNotification");
   QuitterDelegate quitter;
+  MessageLoop* message_loop = IOMessageLoop();
+
   multi_process_notification::Listener listener(
       local_notification, multi_process_notification::UserDomain, &quitter);
-  MessageLoop* message_loop = IOMessageLoop();
   ASSERT_TRUE(listener.Start(message_loop));
   SpinRunLoop(TestTimeouts::action_max_timeout_ms());
   ASSERT_TRUE(quitter.WasStartedReceived());
+
   ASSERT_TRUE(multi_process_notification::Post(
       local_notification, multi_process_notification::UserDomain));
   SpinRunLoop(TestTimeouts::action_max_timeout_ms());
   ASSERT_TRUE(quitter.WasNotificationReceived());
 }
 
 TEST_F(MultiProcessNotificationTest, MultiListener) {
   std::string local_notification("LocalNotification");
   std::string quit_local_notification("QuitLocalNotification");
 
@@ skipping 60 matching lines @@
 }
 
 MULTIPROCESS_TEST_MAIN(MultiProcessUserNotificationMain) {
   return MultiProcessNotificationMain(multi_process_notification::UserDomain);
 }
 
 MULTIPROCESS_TEST_MAIN(MultiProcessSystemNotificationMain) {
   return MultiProcessNotificationMain(multi_process_notification::SystemDomain);
 }
 
-#endif  // defined(OS_MACOSX)
+#endif  // defined(OS_POSIX)