Mojo: Replace TestWithIOThreadBase with just a helper TestIOThread class.

mojo/system/embedder/embedder_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/embedder/embedder.h"
 
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "mojo/public/system/core.h"
 #include "mojo/system/embedder/platform_channel_pair.h"
 #include "mojo/system/embedder/test_embedder.h"
 #include "mojo/system/test_utils.h"
+#include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace embedder {
 namespace {
 
-typedef system::test::TestWithIOThreadBase EmbedderTest;
+class EmbedderTest : public testing::Test {
+ public:
+  EmbedderTest() {}
+  virtual ~EmbedderTest() {}
+
+ protected:
+  system::test::TestIOThread* io_thread() { return &io_thread_; }
+
+ private:
+  system::test::TestIOThread io_thread_;
+
+  DISALLOW_COPY_AND_ASSIGN(EmbedderTest);
+};
 
 void StoreChannelInfo(ChannelInfo** store_channel_info_here,
                       ChannelInfo* channel_info) {
   CHECK(store_channel_info_here);
   CHECK(channel_info);
   *store_channel_info_here = channel_info;
 }
 
 TEST_F(EmbedderTest, ChannelsBasic) {
   Init();
 
   PlatformChannelPair channel_pair;
   ScopedPlatformHandle server_handle = channel_pair.PassServerHandle();
   ScopedPlatformHandle client_handle = channel_pair.PassClientHandle();
 
   ChannelInfo* server_channel_info = NULL;
   MojoHandle server_mp = CreateChannel(server_handle.Pass(),
-                                       io_thread_task_runner(),
+                                       io_thread()->task_runner(),
                                        base::Bind(&StoreChannelInfo,
                                                   &server_channel_info));
   EXPECT_NE(server_mp, MOJO_HANDLE_INVALID);
 
   ChannelInfo* client_channel_info = NULL;
   MojoHandle client_mp = CreateChannel(client_handle.Pass(),
-                                       io_thread_task_runner(),
+                                       io_thread()->task_runner(),
                                        base::Bind(&StoreChannelInfo,
                                                   &client_channel_info));
   EXPECT_NE(client_mp, MOJO_HANDLE_INVALID);
 
   // We can write to a message pipe handle immediately.
   const char kHello[] = "hello";
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoWriteMessage(server_mp, kHello,
                              static_cast<uint32_t>(sizeof(kHello)), NULL, 0,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Now wait for the other side to become readable.
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoWait(client_mp, MOJO_WAIT_FLAG_READABLE,
                      MOJO_DEADLINE_INDEFINITE));
 
   char buffer[1000] = {};
   uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoReadMessage(client_mp, buffer, &num_bytes, NULL, NULL,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), num_bytes);
   EXPECT_STREQ(kHello, buffer);
 
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(server_mp));
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(client_mp));
 
   EXPECT_TRUE(server_channel_info != NULL);
-  system::test::PostTaskAndWait(io_thread_task_runner(),
+  system::test::PostTaskAndWait(io_thread()->task_runner(),
                                 FROM_HERE,
                                 base::Bind(&DestroyChannelOnIOThread,
                                            server_channel_info));
 
   EXPECT_TRUE(client_channel_info != NULL);
-  system::test::PostTaskAndWait(io_thread_task_runner(),
+  system::test::PostTaskAndWait(io_thread()->task_runner(),
                                 FROM_HERE,
                                 base::Bind(&DestroyChannelOnIOThread,
                                            client_channel_info));
 
   EXPECT_TRUE(test::Shutdown());
 }
 
 TEST_F(EmbedderTest, ChannelsHandlePassing) {
   Init();
 
   PlatformChannelPair channel_pair;
   ScopedPlatformHandle server_handle = channel_pair.PassServerHandle();
   ScopedPlatformHandle client_handle = channel_pair.PassClientHandle();
 
   ChannelInfo* server_channel_info = NULL;
   MojoHandle server_mp = CreateChannel(server_handle.Pass(),
-                                       io_thread_task_runner(),
+                                       io_thread()->task_runner(),
                                        base::Bind(&StoreChannelInfo,
                                                   &server_channel_info));
   EXPECT_NE(server_mp, MOJO_HANDLE_INVALID);
 
   ChannelInfo* client_channel_info = NULL;
   MojoHandle client_mp = CreateChannel(client_handle.Pass(),
-                                       io_thread_task_runner(),
+                                       io_thread()->task_runner(),
                                        base::Bind(&StoreChannelInfo,
                                                   &client_channel_info));
   EXPECT_NE(client_mp, MOJO_HANDLE_INVALID);
 
   MojoHandle h0, h1;
   EXPECT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(&h0, &h1));
 
   // Write a message to |h0| (attaching nothing).
   const char kHello[] = "hello";
   EXPECT_EQ(MOJO_RESULT_OK,
@@ skipping 91 matching lines @@
 
   EXPECT_TRUE(test::Shutdown());
 }
 
 // TODO(vtl): Test immediate write & close.
 // TODO(vtl): Test broken-connection cases.
 
 }  // namespace
 }  // namespace embedder
 }  // namespace mojo