Mojo: Replace TestWithIOThreadBase with just a helper TestIOThread class.

mojo/system/raw_channel_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/system/raw_channel.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"  // For |Sleep()|.
 #include "base/threading/simple_thread.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "mojo/common/test/test_utils.h"
 #include "mojo/system/embedder/platform_channel_pair.h"
 #include "mojo/system/embedder/platform_handle.h"
 #include "mojo/system/embedder/scoped_platform_handle.h"
 #include "mojo/system/message_in_transit.h"
 #include "mojo/system/test_utils.h"
+#include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_POSIX)
 #include <sys/socket.h>
 #endif
 
 namespace mojo {
 namespace system {
 namespace {
 
 scoped_ptr<MessageInTransit> MakeTestMessage(uint32_t num_bytes) {
@@ skipping 24 matching lines @@
   scoped_ptr<MessageInTransit> message(MakeTestMessage(num_bytes));
 
   size_t write_size = 0;
   mojo::test::BlockingWrite(
       handle, message->main_buffer(), message->main_buffer_size(), &write_size);
   return write_size == message->main_buffer_size();
 }
 
 // -----------------------------------------------------------------------------
 
-class RawChannelTest : public test::TestWithIOThreadBase {
+class RawChannelTest : public testing::Test {
  public:
   RawChannelTest() {}
   virtual ~RawChannelTest() {}
 
   virtual void SetUp() OVERRIDE {
-    test::TestWithIOThreadBase::SetUp();
-
     embedder::PlatformChannelPair channel_pair;
     handles[0] = channel_pair.PassServerHandle();
     handles[1] = channel_pair.PassClientHandle();
   }
 
   virtual void TearDown() OVERRIDE {
     handles[0].reset();
     handles[1].reset();
-
-    test::TestWithIOThreadBase::TearDown();
   }
 
  protected:
+  test::TestIOThread* io_thread() { return &io_thread_; }
+
   embedder::ScopedPlatformHandle handles[2];
 
  private:
+  test::TestIOThread io_thread_;
+
   DISALLOW_COPY_AND_ASSIGN(RawChannelTest);
 };
 
 // RawChannelTest.WriteMessage -------------------------------------------------
 
 class WriteOnlyRawChannelDelegate : public RawChannel::Delegate {
  public:
   WriteOnlyRawChannelDelegate() {}
   virtual ~WriteOnlyRawChannelDelegate() {}
 
@@ skipping 76 matching lines @@
   std::vector<unsigned char> bytes_;
 
   DISALLOW_COPY_AND_ASSIGN(TestMessageReaderAndChecker);
 };
 
 // Tests writing (and verifies reading using our own custom reader).
 TEST_F(RawChannelTest, WriteMessage) {
   WriteOnlyRawChannelDelegate delegate;
   scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass(),
                                                &delegate,
-                                               io_thread_message_loop()));
+                                               io_thread()->message_loop()));
 
   TestMessageReaderAndChecker checker(handles[1].get());
 
-  test::PostTaskAndWait(io_thread_task_runner(),
+  test::PostTaskAndWait(io_thread()->task_runner(),
                         FROM_HERE,
                         base::Bind(&InitOnIOThread, rc.get()));
 
   // Write and read, for a variety of sizes.
   for (uint32_t size = 1; size < 5 * 1000 * 1000; size += size / 2 + 1) {
     EXPECT_TRUE(rc->WriteMessage(MakeTestMessage(size)));
     EXPECT_TRUE(checker.ReadAndCheckNextMessage(size)) << size;
   }
 
   // Write/queue and read afterwards, for a variety of sizes.
   for (uint32_t size = 1; size < 5 * 1000 * 1000; size += size / 2 + 1)
     EXPECT_TRUE(rc->WriteMessage(MakeTestMessage(size)));
   for (uint32_t size = 1; size < 5 * 1000 * 1000; size += size / 2 + 1)
     EXPECT_TRUE(checker.ReadAndCheckNextMessage(size)) << size;
 
-  test::PostTaskAndWait(io_thread_task_runner(),
+  test::PostTaskAndWait(io_thread()->task_runner(),
                         FROM_HERE,
                         base::Bind(&RawChannel::Shutdown,
                                    base::Unretained(rc.get())));
 }
 
 // RawChannelTest.OnReadMessage ------------------------------------------------
 
 class ReadCheckerRawChannelDelegate : public RawChannel::Delegate {
  public:
   ReadCheckerRawChannelDelegate()
@@ skipping 50 matching lines @@
   size_t position_;
 
   DISALLOW_COPY_AND_ASSIGN(ReadCheckerRawChannelDelegate);
 };
 
 // Tests reading (writing using our own custom writer).
 TEST_F(RawChannelTest, OnReadMessage) {
   ReadCheckerRawChannelDelegate delegate;
   scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass(),
                                                &delegate,
-                                               io_thread_message_loop()));
+                                               io_thread()->message_loop()));
 
-  test::PostTaskAndWait(io_thread_task_runner(),
+  test::PostTaskAndWait(io_thread()->task_runner(),
                         FROM_HERE,
                         base::Bind(&InitOnIOThread, rc.get()));
 
   // Write and read, for a variety of sizes.
   for (uint32_t size = 1; size < 5 * 1000 * 1000; size += size / 2 + 1) {
     delegate.SetExpectedSizes(std::vector<uint32_t>(1, size));
 
     EXPECT_TRUE(WriteTestMessageToHandle(handles[1].get(), size));
 
     delegate.Wait();
   }
 
   // Set up reader and write as fast as we can.
   // Write/queue and read afterwards, for a variety of sizes.
   std::vector<uint32_t> expected_sizes;
   for (uint32_t size = 1; size < 5 * 1000 * 1000; size += size / 2 + 1)
     expected_sizes.push_back(size);
   delegate.SetExpectedSizes(expected_sizes);
   for (uint32_t size = 1; size < 5 * 1000 * 1000; size += size / 2 + 1)
     EXPECT_TRUE(WriteTestMessageToHandle(handles[1].get(), size));
   delegate.Wait();
 
-  test::PostTaskAndWait(io_thread_task_runner(),
+  test::PostTaskAndWait(io_thread()->task_runner(),
                         FROM_HERE,
                         base::Bind(&RawChannel::Shutdown,
                                    base::Unretained(rc.get())));
 }
 
 // RawChannelTest.WriteMessageAndOnReadMessage ---------------------------------
 
 class RawChannelWriterThread : public base::SimpleThread {
  public:
   RawChannelWriterThread(RawChannel* raw_channel, size_t write_count)
@@ skipping 60 matching lines @@
 };
 
 TEST_F(RawChannelTest, WriteMessageAndOnReadMessage) {
   static const size_t kNumWriterThreads = 10;
   static const size_t kNumWriteMessagesPerThread = 4000;
 
   WriteOnlyRawChannelDelegate writer_delegate;
   scoped_ptr<RawChannel> writer_rc(
       RawChannel::Create(handles[0].Pass(),
                          &writer_delegate,
-                         io_thread_message_loop()));
+                         io_thread()->message_loop()));
 
-  test::PostTaskAndWait(io_thread_task_runner(),
+  test::PostTaskAndWait(io_thread()->task_runner(),
                         FROM_HERE,
                         base::Bind(&InitOnIOThread, writer_rc.get()));
 
   ReadCountdownRawChannelDelegate reader_delegate(
       kNumWriterThreads * kNumWriteMessagesPerThread);
   scoped_ptr<RawChannel> reader_rc(
       RawChannel::Create(handles[1].Pass(),
                          &reader_delegate,
-                         io_thread_message_loop()));
+                         io_thread()->message_loop()));
 
-  test::PostTaskAndWait(io_thread_task_runner(),
+  test::PostTaskAndWait(io_thread()->task_runner(),
                         FROM_HERE,
                         base::Bind(&InitOnIOThread, reader_rc.get()));
 
   {
     ScopedVector<RawChannelWriterThread> writer_threads;
     for (size_t i = 0; i < kNumWriterThreads; i++) {
       writer_threads.push_back(new RawChannelWriterThread(
           writer_rc.get(), kNumWriteMessagesPerThread));
     }
     for (size_t i = 0; i < writer_threads.size(); i++)
       writer_threads[i]->Start();
   }  // Joins all the writer threads.
 
   // Sleep a bit, to let any extraneous reads be processed. (There shouldn't be
   // any, but we want to know about them.)
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
 
   // Wait for reading to finish.
   reader_delegate.Wait();
 
-  test::PostTaskAndWait(io_thread_task_runner(),
+  test::PostTaskAndWait(io_thread()->task_runner(),
                         FROM_HERE,
                         base::Bind(&RawChannel::Shutdown,
                                    base::Unretained(reader_rc.get())));
 
-  test::PostTaskAndWait(io_thread_task_runner(),
+  test::PostTaskAndWait(io_thread()->task_runner(),
                         FROM_HERE,
                         base::Bind(&RawChannel::Shutdown,
                                    base::Unretained(writer_rc.get())));
 }
 
 // RawChannelTest.OnFatalError -------------------------------------------------
 
 class FatalErrorRecordingRawChannelDelegate
     : public ReadCountdownRawChannelDelegate {
  public:
@@ skipping 37 matching lines @@
 };
 
 // Tests fatal errors.
 // TODO(vtl): Figure out how to make reading fail reliably. (I'm not convinced
 // that it does.)
 TEST_F(RawChannelTest, OnFatalError) {
   FatalErrorRecordingRawChannelDelegate delegate(0, false, true);
 
   scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass(),
                                                &delegate,
-                                               io_thread_message_loop()));
+                                               io_thread()->message_loop()));
 
-  test::PostTaskAndWait(io_thread_task_runner(),
+  test::PostTaskAndWait(io_thread()->task_runner(),
                         FROM_HERE,
                         base::Bind(&InitOnIOThread, rc.get()));
 
   // Close the handle of the other end, which should make writing fail.
   handles[1].reset();
 
   EXPECT_FALSE(rc->WriteMessage(MakeTestMessage(1)));
 
   // TODO(vtl): In theory, it's conceivable that closing the other end might
   // lead to read failing. In practice, it doesn't seem to.
   delegate.WaitForFatalError();
 
   EXPECT_FALSE(rc->WriteMessage(MakeTestMessage(2)));
 
   // Sleep a bit, to make sure we don't get another |OnFatalError()|
   // notification. (If we actually get another one, |OnFatalError()| crashes.)
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
 
-  test::PostTaskAndWait(io_thread_task_runner(),
+  test::PostTaskAndWait(io_thread()->task_runner(),
                         FROM_HERE,
                         base::Bind(&RawChannel::Shutdown,
                                    base::Unretained(rc.get())));
 }
 
 #if defined(OS_POSIX)
 // RawChannelTest.ReadUnaffectedByWriteFatalError ------------------------------
 
 // TODO(yzshen): On Windows, I haven't figured out a way to shut down one
 // direction of the named pipe.
 TEST_F(RawChannelTest, ReadUnaffectedByWriteFatalError) {
   const size_t kMessageCount = 5;
 
   FatalErrorRecordingRawChannelDelegate delegate(2 * kMessageCount, false,
                                                  true);
   scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass(),
                                                &delegate,
-                                               io_thread_message_loop()));
+                                               io_thread()->message_loop()));
 
-  test::PostTaskAndWait(io_thread_task_runner(),
+  test::PostTaskAndWait(io_thread()->task_runner(),
                         FROM_HERE,
                         base::Bind(&InitOnIOThread, rc.get()));
 
   // Write into the other end a few messages.
   uint32_t message_size = 1;
   for (size_t count = 0; count < kMessageCount;
        ++count, message_size += message_size / 2 + 1) {
     EXPECT_TRUE(WriteTestMessageToHandle(handles[1].get(), message_size));
   }
 
@@ skipping 11 matching lines @@
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
 
   // Write into the other end a few more messages.
   for (size_t count = 0; count < kMessageCount;
        ++count, message_size += message_size / 2 + 1) {
     EXPECT_TRUE(WriteTestMessageToHandle(handles[1].get(), message_size));
   }
   // Wait for reading to finish. A writing failure shouldn't affect reading.
   delegate.Wait();
 
-  test::PostTaskAndWait(io_thread_task_runner(),
+  test::PostTaskAndWait(io_thread()->task_runner(),
                         FROM_HERE,
                         base::Bind(&RawChannel::Shutdown,
                                    base::Unretained(rc.get())));
 }
 #endif  // defined(OS_POSIX)
 
 // RawChannelTest.WriteMessageAfterShutdown ------------------------------------
 
 // Makes sure that calling |WriteMessage()| after |Shutdown()| behaves
 // correctly.
 TEST_F(RawChannelTest, WriteMessageAfterShutdown) {
   WriteOnlyRawChannelDelegate delegate;
   scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass(),
                                                &delegate,
-                                               io_thread_message_loop()));
+                                               io_thread()->message_loop()));
 
-  test::PostTaskAndWait(io_thread_task_runner(),
+  test::PostTaskAndWait(io_thread()->task_runner(),
                         FROM_HERE,
                         base::Bind(&InitOnIOThread, rc.get()));
-  test::PostTaskAndWait(io_thread_task_runner(),
+  test::PostTaskAndWait(io_thread()->task_runner(),
                         FROM_HERE,
                         base::Bind(&RawChannel::Shutdown,
                                    base::Unretained(rc.get())));
 
   EXPECT_FALSE(rc->WriteMessage(MakeTestMessage(1)));
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo