Revert of Change most IPC tests to use ChannelMojo.

ipc/ipc_send_fds_test.cc

 // Copyright (c) 2012 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 "build/build_config.h"
 
 #if defined(OS_POSIX)
 #if defined(OS_MACOSX)
 extern "C" {
 #include <sandbox.h>
@@ skipping 95 matching lines @@
     ++num_fds_received_;
     if (num_fds_received_ == kNumFDsToSend * kNumMessages)
       base::MessageLoop::current()->QuitWhenIdle();
   }
 
  private:
   ino_t expected_inode_num_;
   unsigned num_fds_received_;
 };
 
-class IPCSendFdsTest : public IPCChannelMojoTestBase {
+
+class IPCSendFdsTest : public IPCTestBase {
  protected:
   void RunServer() {
     // Set up IPC channel and start client.
     MyChannelDescriptorListener listener(-1);
     CreateChannel(&listener);
     ASSERT_TRUE(ConnectChannel());
+    ASSERT_TRUE(StartClient());
 
     for (unsigned i = 0; i < kNumMessages; ++i) {
       IPC::Message* message =
           new IPC::Message(0, 3, IPC::Message::PRIORITY_NORMAL);
       for (unsigned j = 0; j < kNumFDsToSend; ++j) {
         const int fd = open(kDevZeroPath, O_RDONLY);
         ASSERT_GE(fd, 0);
         base::FileDescriptor descriptor(fd, true);
         IPC::ParamTraits<base::FileDescriptor>::Write(message, descriptor);
       }
       ASSERT_TRUE(sender()->Send(message));
     }
 
     // Run message loop.
     base::RunLoop().Run();
 
     // Close the channel so the client's OnChannelError() gets fired.
     channel()->Close();
 
     EXPECT_TRUE(WaitForClientShutdown());
     DestroyChannel();
   }
 };
 
 TEST_F(IPCSendFdsTest, DescriptorTest) {
   Init("SendFdsClient");
   RunServer();
 }
 
-class SendFdsTestClientFixture : public IpcChannelMojoTestClient {
- protected:
-  void SendFdsClientCommon(const std::string& test_client_name,
-                           ino_t expected_inode_num) {
-    MyChannelDescriptorListener listener(expected_inode_num);
+int SendFdsClientCommon(const std::string& test_client_name,
+                        ino_t expected_inode_num) {
+  base::MessageLoopForIO main_message_loop;
+  MyChannelDescriptorListener listener(expected_inode_num);
 
-    // Set up IPC channel.
-    Connect(&listener);
+  // Set up IPC channel.
+  std::unique_ptr<IPC::Channel> channel(IPC::Channel::CreateClient(
+      IPCTestBase::GetChannelName(test_client_name), &listener,
+      main_message_loop.task_runner()));
+  CHECK(channel->Connect());
 
-    // Run message loop.
-    base::RunLoop().Run();
+  // Run message loop.
+  base::RunLoop().Run();
 
-    // Verify that the message loop was exited due to getting the correct number
-    // of descriptors, and not because of the channel closing unexpectedly.
-    EXPECT_TRUE(listener.GotExpectedNumberOfDescriptors());
+  // Verify that the message loop was exited due to getting the correct number
+  // of descriptors, and not because of the channel closing unexpectedly.
+  CHECK(listener.GotExpectedNumberOfDescriptors());
 
-    Close();
-  }
-};
+  return 0;
+}
 
-DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT_WITH_CUSTOM_FIXTURE(
-    SendFdsClient,
-    SendFdsTestClientFixture) {
+MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendFdsClient) {
   struct stat st;
   int fd = open(kDevZeroPath, O_RDONLY);
   fstat(fd, &st);
   EXPECT_GE(IGNORE_EINTR(close(fd)), 0);
-  SendFdsClientCommon("SendFdsClient", st.st_ino);
+  return SendFdsClientCommon("SendFdsClient", st.st_ino);
 }
 
 #if defined(OS_MACOSX)
 // Test that FDs are correctly sent to a sandboxed process.
 // TODO(port): Make this test cross-platform.
 TEST_F(IPCSendFdsTest, DescriptorTestSandboxed) {
   Init("SendFdsSandboxedClient");
   RunServer();
 }
 
-DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT_WITH_CUSTOM_FIXTURE(
-    SendFdsSandboxedClient,
-    SendFdsTestClientFixture) {
+MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendFdsSandboxedClient) {
   struct stat st;
   const int fd = open(kDevZeroPath, O_RDONLY);
   fstat(fd, &st);
-  ASSERT_LE(0, IGNORE_EINTR(close(fd)));
+  if (IGNORE_EINTR(close(fd)) < 0)
+    return -1;
 
   // Enable the sandbox.
   char* error_buff = NULL;
   int error = sandbox::Seatbelt::Init(
       sandbox::Seatbelt::kProfilePureComputation, SANDBOX_NAMED, &error_buff);
-  ASSERT_EQ(0, error);
-  ASSERT_FALSE(error_buff);
+  bool success = (error == 0 && error_buff == NULL);
+  if (!success)
+    return -1;
 
   sandbox::Seatbelt::FreeError(error_buff);
 
   // Make sure sandbox is really enabled.
-  ASSERT_EQ(-1, open(kDevZeroPath, O_RDONLY))
-      << "Sandbox wasn't properly enabled";
+  if (open(kDevZeroPath, O_RDONLY) != -1) {
+    LOG(ERROR) << "Sandbox wasn't properly enabled";
+    return -1;
+  }
 
   // See if we can receive a file descriptor.
-  SendFdsClientCommon("SendFdsSandboxedClient", st.st_ino);
+  return SendFdsClientCommon("SendFdsSandboxedClient", st.st_ino);
 }
 #endif  // defined(OS_MACOSX)
 
 
 class MyCBListener : public MyChannelDescriptorListenerBase {
  public:
   MyCBListener(base::Callback<void(int)> cb, int fds_to_send)
       : MyChannelDescriptorListenerBase(),
         cb_(cb) {
     }
@@ skipping 162 matching lines @@
   base::WaitableEvent received_;
 };
 
 TEST_F(IPCMultiSendingFdsTest, StressTest) {
   Run();
 }
 
 }  // namespace
 
 #endif  // defined(OS_POSIX)