Move scoped_test_dir.* and test_io_thread.* from edk/test to edk/system/test.

mojo/edk/system/ipc_support_unittest.cc

 // Copyright 2015 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/edk/system/ipc_support.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "mojo/edk/embedder/master_process_delegate.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/simple_platform_support.h"
 #include "mojo/edk/embedder/slave_process_delegate.h"
 #include "mojo/edk/system/channel_manager.h"
 #include "mojo/edk/system/connection_identifier.h"
 #include "mojo/edk/system/dispatcher.h"
 #include "mojo/edk/system/message_pipe.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 #include "mojo/edk/system/process_identifier.h"
+#include "mojo/edk/system/test/test_io_thread.h"
 #include "mojo/edk/system/test/timeouts.h"
 #include "mojo/edk/system/waiter.h"
 #include "mojo/edk/test/multiprocess_test_helper.h"
-#include "mojo/edk/test/test_io_thread.h"
 #include "mojo/edk/test/test_utils.h"
 #include "mojo/public/cpp/system/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
-
-using test::TestIOThread;
-
 namespace system {
 namespace {
 
 const char kConnectionIdFlag[] = "test-connection-id";
 
 // Tests writing a message (containing just data) to |write_mp| and then reading
 // it from |read_mp| (it should be the next message, i.e., there should be no
 // other messages already enqueued in that direction).
 void TestWriteReadMessage(MessagePipeDispatcher* write_mp,
                           MessagePipeDispatcher* read_mp) {
@@ skipping 106 matching lines @@
   void OnShutdownComplete() override { NOTREACHED(); }
 
   void OnMasterDisconnect() override { NOTREACHED(); }
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(TestSlaveProcessDelegate);
 };
 
 // Represents the master's side of its connection to a slave.
 class TestSlaveConnection {
  public:
-  TestSlaveConnection(TestIOThread* test_io_thread,
+  TestSlaveConnection(test::TestIOThread* test_io_thread,
                       IPCSupport* master_ipc_support)
       : test_io_thread_(test_io_thread),
         master_ipc_support_(master_ipc_support),
         connection_id_(master_ipc_support_->GenerateConnectionIdentifier()),
         slave_id_(kInvalidProcessIdentifier),
         event_(true, false) {}
   ~TestSlaveConnection() {}
 
   // After this is called, |ShutdownChannelToSlave()| must be called (possibly
   // after |WaitForChannelToSlave()|) before destruction.
@@ skipping 25 matching lines @@
                    slave_id_));
   }
 
   embedder::ScopedPlatformHandle PassSlavePlatformHandle() {
     return slave_platform_handle_.Pass();
   }
 
   const ConnectionIdentifier& connection_id() const { return connection_id_; }
 
  private:
-  TestIOThread* const test_io_thread_;
+  test::TestIOThread* const test_io_thread_;
   IPCSupport* const master_ipc_support_;
   const ConnectionIdentifier connection_id_;
   // The master's message pipe dispatcher.
   RefPtr<MessagePipeDispatcher> message_pipe_;
   ProcessIdentifier slave_id_;
   base::WaitableEvent event_;
   embedder::ScopedPlatformHandle slave_platform_handle_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(TestSlaveConnection);
 };
 
 // Encapsulates the state of a slave. (Note, however, that we share a
 // |PlatformSupport| and an I/O thread.)
 class TestSlave {
  public:
   // Note: Before destruction, |ShutdownIPCSupport()| must be called.
   TestSlave(embedder::PlatformSupport* platform_support,
-            TestIOThread* test_io_thread,
+            test::TestIOThread* test_io_thread,
             embedder::ScopedPlatformHandle platform_handle)
       : test_io_thread_(test_io_thread),
         slave_ipc_support_(platform_support,
                            embedder::ProcessType::SLAVE,
                            test_io_thread->task_runner(),
                            &slave_process_delegate_,
                            test_io_thread->task_runner(),
                            platform_handle.Pass()),
         event_(true, false) {}
   ~TestSlave() {}
@@ skipping 27 matching lines @@
   }
 
   // No other methods may be called after this.
   void ShutdownIPCSupport() {
     test_io_thread_->PostTaskAndWait(
         base::Bind(&IPCSupport::ShutdownOnIOThread,
                    base::Unretained(&slave_ipc_support_)));
   }
 
  private:
-  TestIOThread* const test_io_thread_;
+  test::TestIOThread* const test_io_thread_;
   TestSlaveProcessDelegate slave_process_delegate_;
   IPCSupport slave_ipc_support_;
   base::WaitableEvent event_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(TestSlave);
 };
 
 // Encapsulates both the master and slave sides for each slave.
 class TestSlaveSetup {
  public:
   TestSlaveSetup(embedder::SimplePlatformSupport* platform_support,
-                 TestIOThread* test_io_thread,
+                 test::TestIOThread* test_io_thread,
                  TestMasterProcessDelegate* master_process_delegate,
                  IPCSupport* master_ipc_support)
       : platform_support_(platform_support),
         test_io_thread_(test_io_thread),
         master_process_delegate_(master_process_delegate),
         master_ipc_support_(master_ipc_support) {}
   ~TestSlaveSetup() {
     CHECK(!slave_connection_);
     CHECK(!slave_);
   }
@@ skipping 45 matching lines @@
   TestSlaveConnection* slave_connection() { return slave_connection_.get(); }
   // Note: To close the master message pipe, use |PassMasterMessagePipe()|.
   MessagePipeDispatcher* master_mp() { return master_mp_.get(); }
 
   TestSlave* slave() { return slave_.get(); }
   // Note: To close the slave message pipe, use |PassSlaveMessagePipe()|.
   MessagePipeDispatcher* slave_mp() { return slave_mp_.get(); }
 
  private:
   embedder::SimplePlatformSupport* const platform_support_;
-  TestIOThread* const test_io_thread_;
+  test::TestIOThread* const test_io_thread_;
   TestMasterProcessDelegate* const master_process_delegate_;
   IPCSupport* const master_ipc_support_;
 
   std::unique_ptr<TestSlaveConnection> slave_connection_;
   RefPtr<MessagePipeDispatcher> master_mp_;
 
   std::unique_ptr<TestSlave> slave_;
   RefPtr<MessagePipeDispatcher> slave_mp_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(TestSlaveSetup);
 };
 
 class IPCSupportTest : public testing::Test {
  public:
   // Note: Run master process delegate methods on the I/O thread.
   IPCSupportTest()
-      : test_io_thread_(TestIOThread::StartMode::AUTO),
+      : test_io_thread_(test::TestIOThread::StartMode::AUTO),
         master_ipc_support_(&platform_support_,
                             embedder::ProcessType::MASTER,
                             test_io_thread_.task_runner(),
                             &master_process_delegate_,
                             test_io_thread_.task_runner(),
                             embedder::ScopedPlatformHandle()) {}
   ~IPCSupportTest() override {}
 
   std::unique_ptr<TestSlaveSetup> SetupSlave() {
     std::unique_ptr<TestSlaveSetup> s(
         new TestSlaveSetup(&platform_support_, &test_io_thread_,
                            &master_process_delegate_, &master_ipc_support_));
     s->Init();
     return s;
   }
 
   void ShutdownMasterIPCSupport() {
     test_io_thread_.PostTaskAndWait(
         base::Bind(&IPCSupport::ShutdownOnIOThread,
                    base::Unretained(&master_ipc_support_)));
   }
 
   embedder::SimplePlatformSupport& platform_support() {
     return platform_support_;
   }
-  TestIOThread& test_io_thread() { return test_io_thread_; }
+  test::TestIOThread& test_io_thread() { return test_io_thread_; }
   TestMasterProcessDelegate& master_process_delegate() {
     return master_process_delegate_;
   }
   IPCSupport& master_ipc_support() { return master_ipc_support_; }
 
  private:
   embedder::SimplePlatformSupport platform_support_;
-  TestIOThread test_io_thread_;
+  test::TestIOThread test_io_thread_;
 
   // All tests require a master.
   TestMasterProcessDelegate master_process_delegate_;
   IPCSupport master_ipc_support_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(IPCSupportTest);
 };
 
 using MessagePipeDispatcherPair =
     std::pair<RefPtr<MessagePipeDispatcher>, RefPtr<MessagePipeDispatcher>>;
@@ skipping 252 matching lines @@
 
   ShutdownMasterIPCSupport();
 }
 
 MOJO_MULTIPROCESS_TEST_CHILD_TEST(MultiprocessMasterSlaveInternal) {
   embedder::ScopedPlatformHandle client_platform_handle =
       mojo::test::MultiprocessTestHelper::client_platform_handle.Pass();
   ASSERT_TRUE(client_platform_handle.is_valid());
 
   embedder::SimplePlatformSupport platform_support;
-  TestIOThread test_io_thread(TestIOThread::StartMode::AUTO);
+  test::TestIOThread test_io_thread(test::TestIOThread::StartMode::AUTO);
   TestSlaveProcessDelegate slave_process_delegate;
   // Note: Run process delegate methods on the I/O thread.
   IPCSupport ipc_support(&platform_support, embedder::ProcessType::SLAVE,
                          test_io_thread.task_runner(), &slave_process_delegate,
                          test_io_thread.task_runner(),
                          client_platform_handle.Pass());
 
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   ASSERT_TRUE(command_line.HasSwitch(kConnectionIdFlag));
@@ skipping 21 matching lines @@
 
   test_io_thread.PostTaskAndWait(base::Bind(&IPCSupport::ShutdownOnIOThread,
                                             base::Unretained(&ipc_support)));
 }
 
 // TODO(vtl): Also test the case of the master "dying" before the slave. (The
 // slave should get OnMasterDisconnect(), which we currently don't test.)
 
 }  // namespace system
 }  // namespace mojo