Make HandleWatcher watch on the same thread if the thread is running a MessagePumpMojo.

mojo/common/handle_watcher_unittest.cc

 // Copyright 2013 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 "mojo/common/handle_watcher.h"
 
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/threading/thread.h"
+#include "mojo/common/message_pump_mojo.h"
 #include "mojo/common/time_helper.h"
 #include "mojo/public/cpp/system/core.h"
 #include "mojo/public/cpp/test_support/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace common {
 namespace test {
 
+enum MessageLoopConfig {
+  MESSAGE_LOOP_CONFIG_DEFAULT = 0,
+  MESSAGE_LOOP_CONFIG_MOJO = 1
+};
+
 void ObserveCallback(bool* was_signaled,
                      MojoResult* result_observed,
                      MojoResult result) {
   *was_signaled = true;
   *result_observed = result;
 }
 
 void RunUntilIdle() {
   base::RunLoop run_loop;
   run_loop.RunUntilIdle();
 }
 
 void DeleteWatcherAndForwardResult(
     HandleWatcher* watcher,
     base::Callback<void(MojoResult)> next_callback,
     MojoResult result) {
   delete watcher;
   next_callback.Run(result);
 }
 
+scoped_ptr<base::MessageLoop> CreateMessageLoop(MessageLoopConfig config) {
+  scoped_ptr<base::MessageLoop> loop;
+  if (config == MESSAGE_LOOP_CONFIG_DEFAULT)
+    loop.reset(new base::MessageLoop());
+  else
+    loop.reset(new base::MessageLoop(MessagePumpMojo::Create()));
+  return loop.Pass();
+}
+
 // Helper class to manage the callback and running the message loop waiting for
 // message to be received. Typical usage is something like:
 //   Schedule callback returned from GetCallback().
 //   RunUntilGotCallback();
 //   EXPECT_TRUE(got_callback());
 //   clear_callback();
 class CallbackHelper {
  public:
   CallbackHelper()
       : got_callback_(false),
@@ skipping 41 matching lines @@
 
   // If non-NULL we're in RunUntilGotCallback().
   base::RunLoop* run_loop_;
 
   base::WeakPtrFactory<CallbackHelper> weak_factory_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CallbackHelper);
 };
 
-class HandleWatcherTest : public testing::Test {
+class HandleWatcherTest : public testing::TestWithParam<MessageLoopConfig> {
  public:
-  HandleWatcherTest() {}
+  HandleWatcherTest() : message_loop_(CreateMessageLoop(GetParam())) {}
   virtual ~HandleWatcherTest() {
     test::SetTickClockForTest(NULL);
   }
 
  protected:
+  void TearDownMessageLoop() {
+    message_loop_.reset();
+  }
+
   void InstallTickClock() {
     test::SetTickClockForTest(&tick_clock_);
   }
 
   base::SimpleTestTickClock tick_clock_;
 
  private:
   base::ShadowingAtExitManager at_exit_;
-  base::MessageLoop message_loop_;
+  scoped_ptr<base::MessageLoop> message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(HandleWatcherTest);
 };
 
+INSTANTIATE_TEST_CASE_P(
+    MultipleMessageLoopConfigs, HandleWatcherTest,
+    testing::Values(MESSAGE_LOOP_CONFIG_DEFAULT, MESSAGE_LOOP_CONFIG_MOJO));
+
 // Trivial test case with a single handle to watch.
-TEST_F(HandleWatcherTest, SingleHandler) {
+TEST_P(HandleWatcherTest, SingleHandler) {
   MessagePipe test_pipe;
   ASSERT_TRUE(test_pipe.handle0.is_valid());
   CallbackHelper callback_helper;
   HandleWatcher watcher;
   callback_helper.Start(&watcher, test_pipe.handle0.get());
   RunUntilIdle();
   EXPECT_FALSE(callback_helper.got_callback());
   EXPECT_TRUE(mojo::test::WriteTextMessage(test_pipe.handle1.get(),
                                            std::string()));
   callback_helper.RunUntilGotCallback();
   EXPECT_TRUE(callback_helper.got_callback());
 }
 
 // Creates three handles and notfies them in reverse order ensuring each one is
 // notified appropriately.
-TEST_F(HandleWatcherTest, ThreeHandles) {
+TEST_P(HandleWatcherTest, ThreeHandles) {
   MessagePipe test_pipe1;
   MessagePipe test_pipe2;
   MessagePipe test_pipe3;
   CallbackHelper callback_helper1;
   CallbackHelper callback_helper2;
   CallbackHelper callback_helper3;
   ASSERT_TRUE(test_pipe1.handle0.is_valid());
   ASSERT_TRUE(test_pipe2.handle0.is_valid());
   ASSERT_TRUE(test_pipe3.handle0.is_valid());
 
@@ skipping 44 matching lines @@
                                            std::string()));
   EXPECT_TRUE(mojo::test::WriteTextMessage(test_pipe2.handle1.get(),
                                            std::string()));
   callback_helper2.RunUntilGotCallback();
   EXPECT_FALSE(callback_helper1.got_callback());
   EXPECT_TRUE(callback_helper2.got_callback());
   EXPECT_FALSE(callback_helper3.got_callback());
 }
 
 // Verifies Start() invoked a second time works.
-TEST_F(HandleWatcherTest, Restart) {
+TEST_P(HandleWatcherTest, Restart) {
   MessagePipe test_pipe1;
   MessagePipe test_pipe2;
   CallbackHelper callback_helper1;
   CallbackHelper callback_helper2;
   ASSERT_TRUE(test_pipe1.handle0.is_valid());
   ASSERT_TRUE(test_pipe2.handle0.is_valid());
 
   HandleWatcher watcher1;
   callback_helper1.Start(&watcher1, test_pipe1.handle0.get());
   RunUntilIdle();
@@ skipping 31 matching lines @@
 
   // Write to 1 and make sure it's notified.
   EXPECT_TRUE(mojo::test::WriteTextMessage(test_pipe1.handle1.get(),
                                            std::string()));
   callback_helper1.RunUntilGotCallback();
   EXPECT_TRUE(callback_helper1.got_callback());
   EXPECT_FALSE(callback_helper2.got_callback());
 }
 
 // Verifies deadline is honored.
-TEST_F(HandleWatcherTest, Deadline) {
+TEST_P(HandleWatcherTest, Deadline) {
   InstallTickClock();
 
   MessagePipe test_pipe1;
   MessagePipe test_pipe2;
   MessagePipe test_pipe3;
   CallbackHelper callback_helper1;
   CallbackHelper callback_helper2;
   CallbackHelper callback_helper3;
   ASSERT_TRUE(test_pipe1.handle0.is_valid());
   ASSERT_TRUE(test_pipe2.handle0.is_valid());
@@ skipping 22 matching lines @@
 
   HandleWatcher watcher3;
   callback_helper3.Start(&watcher3, test_pipe3.handle0.get());
 
   callback_helper2.RunUntilGotCallback();
   EXPECT_FALSE(callback_helper1.got_callback());
   EXPECT_TRUE(callback_helper2.got_callback());
   EXPECT_FALSE(callback_helper3.got_callback());
 }
 
-TEST_F(HandleWatcherTest, DeleteInCallback) {
+TEST_P(HandleWatcherTest, DeleteInCallback) {
   MessagePipe test_pipe;
   CallbackHelper callback_helper;
 
   HandleWatcher* watcher = new HandleWatcher();
   callback_helper.StartWithCallback(watcher, test_pipe.handle1.get(),
                                     base::Bind(&DeleteWatcherAndForwardResult,
                                                watcher,
                                                callback_helper.GetCallback()));
   EXPECT_TRUE(mojo::test::WriteTextMessage(test_pipe.handle0.get(),
                                            std::string()));
   callback_helper.RunUntilGotCallback();
   EXPECT_TRUE(callback_helper.got_callback());
 }
 
-TEST(HandleWatcherCleanEnvironmentTest, AbortedOnMessageLoopDestruction) {
+TEST_P(HandleWatcherTest, AbortedOnMessageLoopDestruction) {
   bool was_signaled = false;
   MojoResult result = MOJO_RESULT_OK;
 
-  base::ShadowingAtExitManager at_exit;
   MessagePipe pipe;
   HandleWatcher watcher;
-  {
-    base::MessageLoop loop;
+  watcher.Start(pipe.handle0.get(),
+                MOJO_HANDLE_SIGNAL_READABLE,
+                MOJO_DEADLINE_INDEFINITE,
+                base::Bind(&ObserveCallback, &was_signaled, &result));
 
-    watcher.Start(pipe.handle0.get(),
-                  MOJO_HANDLE_SIGNAL_READABLE,
-                  MOJO_DEADLINE_INDEFINITE,
-                  base::Bind(&ObserveCallback, &was_signaled, &result));
-
-    // Now, let the MessageLoop get torn down. We expect our callback to run.
-  }
+  // Now, let the MessageLoop get torn down. We expect our callback to run.
+  TearDownMessageLoop();
 
   EXPECT_TRUE(was_signaled);
   EXPECT_EQ(MOJO_RESULT_ABORTED, result);
 }
 
 void NeverReached(MojoResult result) {
   FAIL() << "Callback should never be invoked " << result;
 }
 
 // Called on the main thread when a thread is done. Decrements |active_count|
@@ skipping 70 matching lines @@
 
   base::ShadowingAtExitManager at_exit;
   base::MessageLoop message_loop;
   base::RunLoop run_loop;
   ScopedVector<base::Thread> threads;
   int threads_active_counter = kThreadCount;
   // Starts the threads first and then post the task in hopes of having more
   // threads running at once.
   for (int i = 0; i < kThreadCount; ++i) {
     scoped_ptr<base::Thread> thread(new base::Thread("test thread"));
-    thread->Start();
+    if (i % 2) {
+      base::Thread::Options thread_options;
+      thread_options.message_pump_factory =
+          base::Bind(&MessagePumpMojo::Create);
+      thread->StartWithOptions(thread_options);
+    } else {
+      thread->Start();
+    }
     threads.push_back(thread.release());
   }
   for (int i = 0; i < kThreadCount; ++i) {
     threads[i]->task_runner()->PostTask(
         FROM_HERE, base::Bind(&RunStressTest, kWatchCount,
                               message_loop.task_runner(),
                               &run_loop, &threads_active_counter));
   }
   run_loop.Run();
   ASSERT_EQ(0, threads_active_counter);
 }
 
 }  // namespace test
 }  // namespace common
 }  // namespace mojo