Fix up notifications so that they aren't only on Browser IOThread.

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 "chrome/browser/browser_thread.h"
 #include "testing/multiprocess_func_list.h"
 
 #if defined(OS_MACOSX)
 // TODO(dmaclach): Remove defined(OS_MACOSX) once
 //                 MultiProcessNotification is implemented on Win/Linux.
 
 namespace {
 
 const char kStartedNotificationName[] = "MultiProcessTestStartedNotification";
 const char kQuitNotificationName[] = "MultiProcessTestQuitNotification";
@@ skipping 64 matching lines @@
 QuitterDelegate::~QuitterDelegate() {
 }
 
 void QuitterDelegate::OnNotificationReceived(
     const std::string& name, multi_process_notification::Domain domain) {
   SimpleDelegate::OnNotificationReceived(name, domain);
   MessageLoop::current()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
 }
 
 int MultiProcessNotificationMain(multi_process_notification::Domain domain) {
-  BrowserThread browser_thread(BrowserThread::IO);
+  base::Thread thread("MultiProcessNotificationMainIOThread");
   base::Thread::Options options(MessageLoop::TYPE_IO, 0);
-  EXPECT_TRUE(browser_thread.StartWithOptions(options));
+  EXPECT_TRUE(thread.StartWithOptions(options));
   MessageLoop loop;
   QuitterDelegate quitter;
   multi_process_notification::Listener listener(
       kQuitNotificationName, domain, &quitter);
-  EXPECT_TRUE(listener.Start());
+  EXPECT_TRUE(listener.Start(thread.message_loop()));
   SpinRunLoop(TestTimeouts::action_max_timeout_ms());
   EXPECT_TRUE(quitter.WasStartedReceived());
   EXPECT_TRUE(multi_process_notification::Post(kStartedNotificationName,
                                                domain));
   SpinRunLoop(TestTimeouts::action_max_timeout_ms());
   EXPECT_TRUE(quitter.WasNotificationReceived());
   return 0;
 }
 
 }  // namespace
 
 class MultiProcessNotificationTest : public base::MultiProcessTest {
  public:
   MultiProcessNotificationTest();
 
   void PostNotificationTest(multi_process_notification::Domain domain);
   void CrossPostNotificationTest(multi_process_notification::Domain domain);
 
-  static void SetUpTestCase();
-  static void TearDownTestCase();
-
+  virtual void SetUp();
+  MessageLoop* IOMessageLoop() { return io_thread.message_loop(); };
+  
  private:
   MessageLoop loop_;
-  static BrowserThread* g_io_thread;
+  base::Thread io_thread;

[garykac, 2011/01/19 22:49:40]

io_thread_

[dmac, 2011/01/19 23:14:41]

Done.

 };
 
-MultiProcessNotificationTest::MultiProcessNotificationTest() {
+MultiProcessNotificationTest::MultiProcessNotificationTest()
+    : io_thread("MultiProcessNotificationTestThread") {
 }
 
-BrowserThread* MultiProcessNotificationTest::g_io_thread = NULL;
 
-void MultiProcessNotificationTest::SetUpTestCase() {
-  g_io_thread = new BrowserThread(BrowserThread::IO);
+void MultiProcessNotificationTest::SetUp() {
   base::Thread::Options options(MessageLoop::TYPE_IO, 0);
-  ASSERT_TRUE(g_io_thread->StartWithOptions(options));
-}
-
-void MultiProcessNotificationTest::TearDownTestCase() {
-  delete g_io_thread;
+  ASSERT_TRUE(io_thread.StartWithOptions(options));
 }
 
 void MultiProcessNotificationTest::PostNotificationTest(
     multi_process_notification::Domain domain) {
   QuitterDelegate process_started;
   multi_process_notification::Listener listener(
       kStartedNotificationName, domain, &process_started);
-  ASSERT_TRUE(listener.Start());
+  ASSERT_TRUE(listener.Start(io_thread.message_loop()));
   SpinRunLoop(TestTimeouts::action_max_timeout_ms());
   ASSERT_TRUE(process_started.WasStartedReceived());
   std::string process_name;
   switch (domain) {
     case multi_process_notification::ProfileDomain:
       process_name = "MultiProcessProfileNotificationMain";
       break;
 
     case multi_process_notification::UserDomain:
       process_name = "MultiProcessUserNotificationMain";
@@ skipping 28 matching lines @@
       &profile_quitter);
   multi_process_notification::Listener user_listener(
       local_notification, multi_process_notification::UserDomain,
       &user_quitter);
   multi_process_notification::Listener system_listener(
       local_notification, multi_process_notification::SystemDomain,
       &system_quitter);
   multi_process_notification::Listener final_listener(
       final_notification, multi_process_notification::UserDomain,
       &final_quitter);
-
-  ASSERT_TRUE(profile_listener.Start());
+  
+  MessageLoop* message_loop = io_thread.message_loop();
+  ASSERT_TRUE(profile_listener.Start(message_loop));
   SpinRunLoop(TestTimeouts::action_max_timeout_ms());
   ASSERT_TRUE(profile_quitter.WasStartedReceived());
-  ASSERT_TRUE(user_listener.Start());
+  ASSERT_TRUE(user_listener.Start(message_loop));
   SpinRunLoop(TestTimeouts::action_max_timeout_ms());
   ASSERT_TRUE(user_quitter.WasStartedReceived());
-  ASSERT_TRUE(system_listener.Start());
+  ASSERT_TRUE(system_listener.Start(message_loop));
   SpinRunLoop(TestTimeouts::action_max_timeout_ms());
   ASSERT_TRUE(system_quitter.WasStartedReceived());
 
   ASSERT_TRUE(multi_process_notification::Post(local_notification, domain));
   SpinRunLoop(TestTimeouts::action_timeout_ms());
 
   // Now send out a final_notification to queue up a notification
   // after the local_notification and make sure that all listeners have had a
   // chance to process local_notification before we check to see if they
   // were called.
-  ASSERT_TRUE(final_listener.Start());
+  ASSERT_TRUE(final_listener.Start(message_loop));
   SpinRunLoop(TestTimeouts::action_max_timeout_ms());
   EXPECT_TRUE(final_quitter.WasStartedReceived());
   ASSERT_TRUE(multi_process_notification::Post(
       final_notification, multi_process_notification::UserDomain));
   SpinRunLoop(TestTimeouts::action_timeout_ms());
   ASSERT_TRUE(final_quitter.WasNotificationReceived());
   switch (domain) {
     case multi_process_notification::ProfileDomain:
       ASSERT_TRUE(profile_quitter.WasNotificationReceived());
       ASSERT_FALSE(user_quitter.WasNotificationReceived());
@@ skipping 11 matching lines @@
       ASSERT_FALSE(user_quitter.WasNotificationReceived());
       ASSERT_TRUE(system_quitter.WasNotificationReceived());
       break;
   }
 }
 
 TEST_F(MultiProcessNotificationTest, BasicCreationTest) {
   QuitterDelegate quitter;
   multi_process_notification::Listener local_listener(
       "BasicCreationTest", multi_process_notification::UserDomain, &quitter);
-  ASSERT_TRUE(local_listener.Start());
+  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());
+  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);
+  // Should fail because current message loop should not be an IOMessageLoop.
+  ASSERT_FALSE(local_listener2.Start(MessageLoop::current()));
 }
 
 TEST_F(MultiProcessNotificationTest, PostInProcessNotification) {
   std::string local_notification("QuitLocalNotification");
   QuitterDelegate quitter;
   multi_process_notification::Listener listener(
       local_notification, multi_process_notification::UserDomain, &quitter);
-
-  ASSERT_TRUE(listener.Start());
+  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");
 
   SimpleDelegate delegate1;
   SimpleDelegate delegate2;
   multi_process_notification::Listener local_listener1(
       local_notification, multi_process_notification::UserDomain,
       &delegate1);
   multi_process_notification::Listener local_listener2(
       local_notification, multi_process_notification::UserDomain,
       &delegate2);
 
   QuitterDelegate quitter;
 
   multi_process_notification::Listener quit_listener(quit_local_notification,
       multi_process_notification::UserDomain, &quitter);
-
-  ASSERT_TRUE(local_listener1.Start());
+  MessageLoop* message_loop = IOMessageLoop();
+  ASSERT_TRUE(local_listener1.Start(message_loop));
   SpinRunLoop(TestTimeouts::action_max_timeout_ms());
   ASSERT_TRUE(delegate1.WasStartedReceived());
-  ASSERT_TRUE(local_listener2.Start());
+  ASSERT_TRUE(local_listener2.Start(message_loop));
   SpinRunLoop(TestTimeouts::action_max_timeout_ms());
   ASSERT_TRUE(delegate2.WasStartedReceived());
-  ASSERT_TRUE(quit_listener.Start());
+  ASSERT_TRUE(quit_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));
   ASSERT_TRUE(multi_process_notification::Post(
       quit_local_notification, multi_process_notification::UserDomain));
   SpinRunLoop(TestTimeouts::action_max_timeout_ms());
   ASSERT_TRUE(delegate1.WasNotificationReceived());
   ASSERT_TRUE(delegate2.WasNotificationReceived());
   ASSERT_TRUE(quitter.WasNotificationReceived());
@@ skipping 30 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)