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,
+  MESSAGE_LOOP_CONFIG_COUNT = 2
+};
+
 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;
+  switch (config) {
+    case MESSAGE_LOOP_CONFIG_DEFAULT:
+      loop.reset(new base::MessageLoop());
+      break;
+    case MESSAGE_LOOP_CONFIG_MOJO:
+      loop.reset(new base::MessageLoop(MessagePumpMojo::Create()));
+      break;
+    case MESSAGE_LOOP_CONFIG_COUNT:
+      break;

[sky, 2014/08/28 23:12:19]

NOTREACHED

[yzshen1, 2014/08/29 00:23:45]

This 'case' is removed entirely.

+  }
+  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 43 matching lines @@
   base::RunLoop* run_loop_;
 
   base::WeakPtrFactory<CallbackHelper> weak_factory_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CallbackHelper);
 };
 
 class HandleWatcherTest : public testing::Test {
  public:
-  HandleWatcherTest() {}
+  HandleWatcherTest() : next_message_loop_config_(MESSAGE_LOOP_CONFIG_DEFAULT) {
+  }
   virtual ~HandleWatcherTest() {
     test::SetTickClockForTest(NULL);
   }
 
  protected:
+  bool NextTestConfig() {
+    if (next_message_loop_config_ == MESSAGE_LOOP_CONFIG_COUNT)
+      return false;
+
+    // We have to destroy the current message loop before we create a new one.
+    message_loop_.reset();
+
+    message_loop_ = CreateMessageLoop(next_message_loop_config_);
+    next_message_loop_config_ = static_cast<MessageLoopConfig>(
+        next_message_loop_config_ + 1);
+    return true;
+  }
+
   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_;
+  MessageLoopConfig next_message_loop_config_;
 
   DISALLOW_COPY_AND_ASSIGN(HandleWatcherTest);
 };
 
 // Trivial test case with a single handle to watch.
 TEST_F(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());
+  while (NextTestConfig()) {
+    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) {
-  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());
-
-  HandleWatcher watcher1;
-  callback_helper1.Start(&watcher1, test_pipe1.handle0.get());
-  RunUntilIdle();
-  EXPECT_FALSE(callback_helper1.got_callback());
-  EXPECT_FALSE(callback_helper2.got_callback());
-  EXPECT_FALSE(callback_helper3.got_callback());
-
-  HandleWatcher watcher2;
-  callback_helper2.Start(&watcher2, test_pipe2.handle0.get());
-  RunUntilIdle();
-  EXPECT_FALSE(callback_helper1.got_callback());
-  EXPECT_FALSE(callback_helper2.got_callback());
-  EXPECT_FALSE(callback_helper3.got_callback());
-
-  HandleWatcher watcher3;
-  callback_helper3.Start(&watcher3, test_pipe3.handle0.get());
-  RunUntilIdle();
-  EXPECT_FALSE(callback_helper1.got_callback());
-  EXPECT_FALSE(callback_helper2.got_callback());
-  EXPECT_FALSE(callback_helper3.got_callback());
-
-  // Write to 3 and make sure it's notified.
-  EXPECT_TRUE(mojo::test::WriteTextMessage(test_pipe3.handle1.get(),
-                                           std::string()));
-  callback_helper3.RunUntilGotCallback();
-  EXPECT_FALSE(callback_helper1.got_callback());
-  EXPECT_FALSE(callback_helper2.got_callback());
-  EXPECT_TRUE(callback_helper3.got_callback());
-  callback_helper3.clear_callback();
-
-  // Write to 1 and 3. Only 1 should be notified since 3 was is no longer
-  // running.
-  EXPECT_TRUE(mojo::test::WriteTextMessage(test_pipe1.handle1.get(),
-                                           std::string()));
-  EXPECT_TRUE(mojo::test::WriteTextMessage(test_pipe3.handle1.get(),
-                                           std::string()));
-  callback_helper1.RunUntilGotCallback();
-  EXPECT_TRUE(callback_helper1.got_callback());
-  EXPECT_FALSE(callback_helper2.got_callback());
-  EXPECT_FALSE(callback_helper3.got_callback());
-  callback_helper1.clear_callback();
-
-  // Write to 1 and 2. Only 2 should be notified (since 1 was already notified).
-  EXPECT_TRUE(mojo::test::WriteTextMessage(test_pipe1.handle1.get(),
-                                           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());
+  while (NextTestConfig()) {

[sky, 2014/08/28 23:12:19]

Did you look into making these parameterized tests:
https://code.google.com/p/googletest/wiki/AdvancedGuide#Value_Parameterized_T...
?

[yzshen1, 2014/08/29 00:23:45]

Great suggestion!

+    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());
+
+    HandleWatcher watcher1;
+    callback_helper1.Start(&watcher1, test_pipe1.handle0.get());
+    RunUntilIdle();
+    EXPECT_FALSE(callback_helper1.got_callback());
+    EXPECT_FALSE(callback_helper2.got_callback());
+    EXPECT_FALSE(callback_helper3.got_callback());
+
+    HandleWatcher watcher2;
+    callback_helper2.Start(&watcher2, test_pipe2.handle0.get());
+    RunUntilIdle();
+    EXPECT_FALSE(callback_helper1.got_callback());
+    EXPECT_FALSE(callback_helper2.got_callback());
+    EXPECT_FALSE(callback_helper3.got_callback());
+
+    HandleWatcher watcher3;
+    callback_helper3.Start(&watcher3, test_pipe3.handle0.get());
+    RunUntilIdle();
+    EXPECT_FALSE(callback_helper1.got_callback());
+    EXPECT_FALSE(callback_helper2.got_callback());
+    EXPECT_FALSE(callback_helper3.got_callback());
+
+    // Write to 3 and make sure it's notified.
+    EXPECT_TRUE(mojo::test::WriteTextMessage(test_pipe3.handle1.get(),
+                                             std::string()));
+    callback_helper3.RunUntilGotCallback();
+    EXPECT_FALSE(callback_helper1.got_callback());
+    EXPECT_FALSE(callback_helper2.got_callback());
+    EXPECT_TRUE(callback_helper3.got_callback());
+    callback_helper3.clear_callback();
+
+    // Write to 1 and 3. Only 1 should be notified since 3 was is no longer
+    // running.
+    EXPECT_TRUE(mojo::test::WriteTextMessage(test_pipe1.handle1.get(),
+                                             std::string()));
+    EXPECT_TRUE(mojo::test::WriteTextMessage(test_pipe3.handle1.get(),
+                                             std::string()));
+    callback_helper1.RunUntilGotCallback();
+    EXPECT_TRUE(callback_helper1.got_callback());
+    EXPECT_FALSE(callback_helper2.got_callback());
+    EXPECT_FALSE(callback_helper3.got_callback());
+    callback_helper1.clear_callback();
+
+    // Write to 1 and 2. Only 2 should be notified (since 1 was already
+    // notified).
+    EXPECT_TRUE(mojo::test::WriteTextMessage(test_pipe1.handle1.get(),
+                                             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) {
-  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();
-  EXPECT_FALSE(callback_helper1.got_callback());
-  EXPECT_FALSE(callback_helper2.got_callback());
-
-  HandleWatcher watcher2;
-  callback_helper2.Start(&watcher2, test_pipe2.handle0.get());
-  RunUntilIdle();
-  EXPECT_FALSE(callback_helper1.got_callback());
-  EXPECT_FALSE(callback_helper2.got_callback());
-
-  // 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());
-  callback_helper1.clear_callback();
-  EXPECT_TRUE(mojo::test::DiscardMessage(test_pipe1.handle0.get()));
-
-  // Write to 2 and make sure it's notified.
-  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());
-  callback_helper2.clear_callback();
-
-  // Listen on 1 again.
-  callback_helper1.Start(&watcher1, test_pipe1.handle0.get());
-  RunUntilIdle();
-  EXPECT_FALSE(callback_helper1.got_callback());
-  EXPECT_FALSE(callback_helper2.got_callback());
-
-  // 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());
+  while (NextTestConfig()) {
+    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();
+    EXPECT_FALSE(callback_helper1.got_callback());
+    EXPECT_FALSE(callback_helper2.got_callback());
+
+    HandleWatcher watcher2;
+    callback_helper2.Start(&watcher2, test_pipe2.handle0.get());
+    RunUntilIdle();
+    EXPECT_FALSE(callback_helper1.got_callback());
+    EXPECT_FALSE(callback_helper2.got_callback());
+
+    // 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());
+    callback_helper1.clear_callback();
+    EXPECT_TRUE(mojo::test::DiscardMessage(test_pipe1.handle0.get()));
+
+    // Write to 2 and make sure it's notified.
+    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());
+    callback_helper2.clear_callback();
+
+    // Listen on 1 again.
+    callback_helper1.Start(&watcher1, test_pipe1.handle0.get());
+    RunUntilIdle();
+    EXPECT_FALSE(callback_helper1.got_callback());
+    EXPECT_FALSE(callback_helper2.got_callback());
+
+    // 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) {
-  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());
-  ASSERT_TRUE(test_pipe3.handle0.is_valid());
-
-  // Add a watcher with an infinite timeout.
-  HandleWatcher watcher1;
-  callback_helper1.Start(&watcher1, test_pipe1.handle0.get());
-  RunUntilIdle();
-  EXPECT_FALSE(callback_helper1.got_callback());
-  EXPECT_FALSE(callback_helper2.got_callback());
-  EXPECT_FALSE(callback_helper3.got_callback());
-
-  // Add another watcher wth a timeout of 500 microseconds.
-  HandleWatcher watcher2;
-  watcher2.Start(test_pipe2.handle0.get(), MOJO_HANDLE_SIGNAL_READABLE, 500,
-                 callback_helper2.GetCallback());
-  RunUntilIdle();
-  EXPECT_FALSE(callback_helper1.got_callback());
-  EXPECT_FALSE(callback_helper2.got_callback());
-  EXPECT_FALSE(callback_helper3.got_callback());
-
-  // Advance the clock passed the deadline. We also have to start another
-  // watcher to wake up the background thread.
-  tick_clock_.Advance(base::TimeDelta::FromMicroseconds(501));
-
-  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());
+  while (NextTestConfig()) {
+    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());
+    ASSERT_TRUE(test_pipe3.handle0.is_valid());
+
+    // Add a watcher with an infinite timeout.
+    HandleWatcher watcher1;
+    callback_helper1.Start(&watcher1, test_pipe1.handle0.get());
+    RunUntilIdle();
+    EXPECT_FALSE(callback_helper1.got_callback());
+    EXPECT_FALSE(callback_helper2.got_callback());
+    EXPECT_FALSE(callback_helper3.got_callback());
+
+    // Add another watcher wth a timeout of 500 microseconds.
+    HandleWatcher watcher2;
+    watcher2.Start(test_pipe2.handle0.get(), MOJO_HANDLE_SIGNAL_READABLE, 500,
+                   callback_helper2.GetCallback());
+    RunUntilIdle();
+    EXPECT_FALSE(callback_helper1.got_callback());
+    EXPECT_FALSE(callback_helper2.got_callback());
+    EXPECT_FALSE(callback_helper3.got_callback());
+
+    // Advance the clock passed the deadline. We also have to start another
+    // watcher to wake up the background thread.
+    tick_clock_.Advance(base::TimeDelta::FromMicroseconds(501));
+
+    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) {
-  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());
+  while (NextTestConfig()) {
+    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) {
-  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));
-
-    // Now, let the MessageLoop get torn down. We expect our callback to run.
-  }
-
-  EXPECT_TRUE(was_signaled);
-  EXPECT_EQ(MOJO_RESULT_ABORTED, result);
+  for (int i = 0; i < MESSAGE_LOOP_CONFIG_COUNT; ++i) {
+    bool was_signaled = false;
+    MojoResult result = MOJO_RESULT_OK;
+
+    base::ShadowingAtExitManager at_exit;
+    MessagePipe pipe;
+    HandleWatcher watcher;
+    {
+      scoped_ptr<base::MessageLoop> loop(
+          CreateMessageLoop(static_cast<MessageLoopConfig>(i)));
+
+      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.
+    }
+
+    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|
 // and if |active_count| is zero quits |run_loop|.
 void StressThreadDone(base::RunLoop* run_loop, int* active_count) {
   (*active_count)--;
@@ skipping 67 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