Make mojo::RunLoop just use pthreads.

mojo/public/cpp/utility/tests/run_loop_unittest.cc

 // Copyright 2014 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/public/cpp/utility/run_loop.h"
 
 #include <string>
 
 #include "mojo/public/cpp/system/macros.h"
 #include "mojo/public/cpp/system/message_pipe.h"
@@ skipping 29 matching lines @@
   }
 
  private:
   int ready_count_;
   int error_count_;
   MojoResult last_error_result_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(TestRunLoopHandler);
 };
 
-class RunLoopTest : public testing::Test {
- public:
-  RunLoopTest() {}
-
-  void SetUp() override {
-    Test::SetUp();
-    RunLoop::SetUp();
-  }
-  void TearDown() override {
-    RunLoop::TearDown();
-    Test::TearDown();
-  }
-
- private:
-  MOJO_DISALLOW_COPY_AND_ASSIGN(RunLoopTest);
-};
-
 // Trivial test to verify Run() with no added handles returns.
-TEST_F(RunLoopTest, ExitsWithNoHandles) {
+TEST(RunLoopTest, ExitsWithNoHandles) {
   RunLoop run_loop;
   run_loop.Run();
 }
 
 class RemoveOnReadyRunLoopHandler : public TestRunLoopHandler {
  public:
   RemoveOnReadyRunLoopHandler() : run_loop_(nullptr) {}
   ~RemoveOnReadyRunLoopHandler() override {}
 
   void set_run_loop(RunLoop* run_loop) { run_loop_ = run_loop; }
 
   // RunLoopHandler:
   void OnHandleReady(const Handle& handle) override {
     run_loop_->RemoveHandler(handle);
     TestRunLoopHandler::OnHandleReady(handle);
   }
 
  private:
   RunLoop* run_loop_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(RemoveOnReadyRunLoopHandler);
 };
 
 // Verifies RunLoop quits when no more handles (handle is removed when ready).
-TEST_F(RunLoopTest, HandleReady) {
+TEST(RunLoopTest, HandleReady) {
   RemoveOnReadyRunLoopHandler handler;
   MessagePipe test_pipe;
   EXPECT_TRUE(test::WriteTextMessage(test_pipe.handle1.get(), std::string()));
 
   RunLoop run_loop;
   handler.set_run_loop(&run_loop);
   run_loop.AddHandler(&handler, test_pipe.handle0.get(),
                       MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE);
   run_loop.Run();
   EXPECT_EQ(1, handler.ready_count());
@@ skipping 14 matching lines @@
     TestRunLoopHandler::OnHandleReady(handle);
   }
 
  private:
   RunLoop* run_loop_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(QuitOnReadyRunLoopHandler);
 };
 
 // Verifies Quit() from OnHandleReady() quits the loop.
-TEST_F(RunLoopTest, QuitFromReady) {
+TEST(RunLoopTest, QuitFromReady) {
   QuitOnReadyRunLoopHandler handler;
   MessagePipe test_pipe;
   EXPECT_TRUE(test::WriteTextMessage(test_pipe.handle1.get(), std::string()));
 
   RunLoop run_loop;
   handler.set_run_loop(&run_loop);
   run_loop.AddHandler(&handler, test_pipe.handle0.get(),
                       MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE);
   run_loop.Run();
   EXPECT_EQ(1, handler.ready_count());
@@ skipping 14 matching lines @@
     TestRunLoopHandler::OnHandleError(handle, result);
   }
 
  private:
   RunLoop* run_loop_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(QuitOnErrorRunLoopHandler);
 };
 
 // Verifies Quit() when the deadline is reached works.
-TEST_F(RunLoopTest, QuitWhenDeadlineExpired) {
+TEST(RunLoopTest, QuitWhenDeadlineExpired) {
   QuitOnErrorRunLoopHandler handler;
   MessagePipe test_pipe;
   RunLoop run_loop;
   handler.set_run_loop(&run_loop);
   run_loop.AddHandler(&handler, test_pipe.handle0.get(),
                       MOJO_HANDLE_SIGNAL_READABLE,
                       static_cast<MojoDeadline>(10000));
   run_loop.Run();
   EXPECT_EQ(0, handler.ready_count());
   EXPECT_EQ(1, handler.error_count());
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, handler.last_error_result());
   EXPECT_FALSE(run_loop.HasHandler(test_pipe.handle0.get()));
 }
 
 // Test that handlers are notified of loop destruction.
-TEST_F(RunLoopTest, Destruction) {
+TEST(RunLoopTest, Destruction) {
   TestRunLoopHandler handler;
   MessagePipe test_pipe;
   {
     RunLoop run_loop;
     run_loop.AddHandler(&handler,
                         test_pipe.handle0.get(),
                         MOJO_HANDLE_SIGNAL_READABLE,
                         MOJO_DEADLINE_INDEFINITE);
   }
   EXPECT_EQ(1, handler.error_count());
@@ skipping 16 matching lines @@
   }
 
  private:
   std::vector<Handle> handles_;
   RunLoop* run_loop_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(RemoveManyRunLoopHandler);
 };
 
 // Test that handlers are notified of loop destruction.
-TEST_F(RunLoopTest, MultipleHandleDestruction) {
+TEST(RunLoopTest, MultipleHandleDestruction) {
   RemoveManyRunLoopHandler odd_handler;
   TestRunLoopHandler even_handler;
   MessagePipe test_pipe1, test_pipe2, test_pipe3;
   {
     RunLoop run_loop;
     odd_handler.set_run_loop(&run_loop);
     odd_handler.add_handle(test_pipe1.handle0.get());
     odd_handler.add_handle(test_pipe3.handle0.get());
     run_loop.AddHandler(&odd_handler,
                         test_pipe1.handle0.get(),
@@ skipping 28 matching lines @@
                           MOJO_DEADLINE_INDEFINITE);
     TestRunLoopHandler::OnHandleError(handle, result);
   }
 
  private:
   RunLoop* run_loop_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(AddHandlerOnErrorHandler);
 };
 
-TEST_F(RunLoopTest, AddHandlerOnError) {
+TEST(RunLoopTest, AddHandlerOnError) {
   AddHandlerOnErrorHandler handler;
   MessagePipe test_pipe;
   {
     RunLoop run_loop;
     handler.set_run_loop(&run_loop);
     run_loop.AddHandler(&handler,
                         test_pipe.handle0.get(),
                         MOJO_HANDLE_SIGNAL_READABLE,
                         MOJO_DEADLINE_INDEFINITE);
   }
   EXPECT_EQ(1, handler.error_count());
   EXPECT_EQ(MOJO_RESULT_ABORTED, handler.last_error_result());
 }
 
-TEST_F(RunLoopTest, Current) {
+TEST(RunLoopTest, Current) {
   EXPECT_TRUE(RunLoop::current() == nullptr);
   {
     RunLoop run_loop;
     EXPECT_EQ(&run_loop, RunLoop::current());
   }
   EXPECT_TRUE(RunLoop::current() == nullptr);
 }
 
 class NestingRunLoopHandler : public TestRunLoopHandler {
  public:
@@ skipping 62 matching lines @@
   MessagePipe* pipe_;
   size_t depth_;
   bool reached_depth_limit_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(NestingRunLoopHandler);
 };
 
 const size_t NestingRunLoopHandler::kDepthLimit = 10;
 const char NestingRunLoopHandler::kSignalMagic = 'X';
 
-TEST_F(RunLoopTest, NestedRun) {
+TEST(RunLoopTest, NestedRun) {
   NestingRunLoopHandler handler;
   MessagePipe test_pipe;
   RunLoop run_loop;
   handler.set_run_loop(&run_loop);
   handler.set_pipe(&test_pipe);
   run_loop.AddHandler(&handler, test_pipe.handle0.get(),
                       MOJO_HANDLE_SIGNAL_READABLE,
                       static_cast<MojoDeadline>(10000));
   handler.WriteSignal();
   run_loop.Run();
 
   EXPECT_TRUE(handler.reached_depth_limit());
   // Got MOJO_RESULT_DEADLINE_EXCEEDED once then removed from the
   // RunLoop's handler list.
   EXPECT_EQ(handler.error_count(), 1);
   EXPECT_EQ(handler.last_error_result(), MOJO_RESULT_DEADLINE_EXCEEDED);
 }
 
 struct Task {
   Task(int num, std::vector<int>* sequence) : num(num), sequence(sequence) {}
 
   void Run() const { sequence->push_back(num); }
 
   int num;
   std::vector<int>* sequence;
 };
 
-TEST_F(RunLoopTest, DelayedTaskOrder) {
+TEST(RunLoopTest, DelayedTaskOrder) {
   std::vector<int> sequence;
   RunLoop run_loop;
   run_loop.PostDelayedTask(Closure(Task(1, &sequence)), 0);
   run_loop.PostDelayedTask(Closure(Task(2, &sequence)), 0);
   run_loop.PostDelayedTask(Closure(Task(3, &sequence)), 0);
   run_loop.RunUntilIdle();
 
   ASSERT_EQ(3u, sequence.size());
   EXPECT_EQ(1, sequence[0]);
   EXPECT_EQ(2, sequence[1]);
   EXPECT_EQ(3, sequence[2]);
 }
 
 struct QuittingTask {
   explicit QuittingTask(RunLoop* run_loop) : run_loop(run_loop) {}
 
   void Run() const { run_loop->Quit(); }
 
   RunLoop* run_loop;
 };
 
-TEST_F(RunLoopTest, QuitFromDelayedTask) {
+TEST(RunLoopTest, QuitFromDelayedTask) {
   TestRunLoopHandler handler;
   MessagePipe test_pipe;
   RunLoop run_loop;
   run_loop.AddHandler(&handler,
                       test_pipe.handle0.get(),
                       MOJO_HANDLE_SIGNAL_READABLE,
                       MOJO_DEADLINE_INDEFINITE);
   run_loop.PostDelayedTask(Closure(QuittingTask(&run_loop)), 0);
   run_loop.Run();
 }
 
 }  // namespace
 }  // namespace mojo