Revert of Adds associated interface support to IPC::Channel

ipc/ipc_channel_mojo_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 "ipc/ipc_channel_mojo.h"
 
 #include <stddef.h>
 #include <stdint.h>
-
 #include <memory>
 #include <utility>
 
 #include "base/base_paths.h"
 #include "base/files/file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/path_service.h"
 #include "base/pickle.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
-#include "base/strings/stringprintf.h"
 #include "base/test/test_io_thread.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_mojo_handle_attachment.h"
 #include "ipc/ipc_mojo_message_helper.h"
 #include "ipc/ipc_mojo_param_traits.h"
-#include "ipc/ipc_test.mojom.h"
 #include "ipc/ipc_test_base.h"
 #include "ipc/ipc_test_channel_listener.h"
 #include "mojo/edk/test/mojo_test_base.h"
 #include "mojo/edk/test/multiprocess_test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_POSIX)
 #include "base/file_descriptor_posix.h"
 #include "ipc/ipc_platform_file_attachment_posix.h"
 #endif
@@ skipping 14 matching lines @@
     test.Main();                                                          \
     return (::testing::Test::HasFatalFailure() ||                         \
             ::testing::Test::HasNonfatalFailure())                        \
                ? 1                                                        \
                : 0;                                                       \
   }                                                                       \
   void client_name##_MainFixture::Main()
 
 namespace {
 
-void SendString(IPC::Sender* sender, const std::string& str) {
-  IPC::Message* message = new IPC::Message(0, 2, IPC::Message::PRIORITY_NORMAL);
-  message->WriteString(str);
-  ASSERT_TRUE(sender->Send(message));
-}
-
 class ListenerThatExpectsOK : public IPC::Listener {
  public:
   ListenerThatExpectsOK() : received_ok_(false) {}
 
   ~ListenerThatExpectsOK() override {}
 
   bool OnMessageReceived(const IPC::Message& message) override {
     base::PickleIterator iter(message);
     std::string should_be_ok;
     EXPECT_TRUE(iter.ReadString(&should_be_ok));
     EXPECT_EQ(should_be_ok, "OK");
     received_ok_ = true;
     base::MessageLoop::current()->QuitWhenIdle();
     return true;
   }
 
   void OnChannelError() override {
     // The connection should be healthy while the listener is waiting
     // message.  An error can occur after that because the peer
     // process dies.
     DCHECK(received_ok_);
   }
 
-  static void SendOK(IPC::Sender* sender) { SendString(sender, "OK"); }
+  static void SendOK(IPC::Sender* sender) {
+    IPC::Message* message =
+        new IPC::Message(0, 2, IPC::Message::PRIORITY_NORMAL);
+    message->WriteString(std::string("OK"));
+    ASSERT_TRUE(sender->Send(message));
+  }
 
  private:
   bool received_ok_;
 };
 
 class ChannelClient {
  public:
   void Init(mojo::ScopedMessagePipeHandle handle) {
     handle_ = std::move(handle);
   }
@@ skipping 15 matching lines @@
   IPC::ChannelMojo* channel() const { return channel_.get(); }
 
  private:
   base::MessageLoopForIO main_message_loop_;
   mojo::ScopedMessagePipeHandle handle_;
   std::unique_ptr<IPC::ChannelMojo> channel_;
 };
 
 class IPCChannelMojoTest : public testing::Test {
  public:
-  IPCChannelMojoTest() {}
+  IPCChannelMojoTest() : io_thread_(base::TestIOThread::Mode::kAutoStart) {}
 
   void TearDown() override { base::RunLoop().RunUntilIdle(); }
 
   void InitWithMojo(const std::string& test_client_name) {
     handle_ = helper_.StartChild(test_client_name);
   }
 
   void CreateChannel(IPC::Listener* listener) {
     channel_ = IPC::ChannelMojo::Create(std::move(handle_),
                                         IPC::Channel::MODE_SERVER, listener);
   }
 
   bool ConnectChannel() { return channel_->Connect(); }
 
   void DestroyChannel() { channel_.reset(); }
 
   bool WaitForClientShutdown() { return helper_.WaitForChildTestShutdown(); }
 
   IPC::Sender* sender() { return channel(); }
   IPC::Channel* channel() { return channel_.get(); }
 
  private:
   base::MessageLoop message_loop_;
+  base::TestIOThread io_thread_;
   mojo::edk::test::MultiprocessTestHelper helper_;
   mojo::ScopedMessagePipeHandle handle_;
   std::unique_ptr<IPC::Channel> channel_;
 };
 
 class TestChannelListenerWithExtraExpectations
     : public IPC::TestChannelListener {
  public:
   TestChannelListenerWithExtraExpectations() : is_connected_called_(false) {}
 
@@ skipping 413 matching lines @@
                                     ChannelClient) {
   ListenerSendingOneOk listener;
   Connect(&listener);
   listener.set_sender(channel());
 
   base::RunLoop().Run();
 
   Close();
 }
 
-class ListenerWithSimpleAssociatedInterface
-    : public IPC::Listener,
-      public IPC::mojom::SimpleTestDriver {
- public:
-  static const int kNumMessages;
-
-  ListenerWithSimpleAssociatedInterface() : binding_(this) {}
-
-  ~ListenerWithSimpleAssociatedInterface() override {}
-
-  bool OnMessageReceived(const IPC::Message& message) override {
-    base::PickleIterator iter(message);
-    std::string should_be_expected;
-    EXPECT_TRUE(iter.ReadString(&should_be_expected));
-    EXPECT_EQ(should_be_expected, next_expected_string_);
-    num_messages_received_++;
-    return true;
-  }
-
-  void OnChannelError() override {
-    DCHECK(received_quit_);
-  }
-
-  void RegisterInterfaceFactory(IPC::Channel* channel) {
-    channel->GetAssociatedInterfaceSupport()->AddAssociatedInterface(
-        base::Bind(&ListenerWithSimpleAssociatedInterface::BindRequest,
-                   base::Unretained(this)));
-  }
-
- private:
-  // IPC::mojom::SimpleTestDriver:
-  void ExpectString(const mojo::String& str) override {
-    next_expected_string_ = str;
-  }
-
-  void RequestQuit(const RequestQuitCallback& callback) override {
-    EXPECT_EQ(kNumMessages, num_messages_received_);
-    received_quit_ = true;
-    callback.Run();
-    base::MessageLoop::current()->QuitWhenIdle();
-  }
-
-  void BindRequest(IPC::mojom::SimpleTestDriverAssociatedRequest request) {
-    DCHECK(!binding_.is_bound());
-    binding_.Bind(std::move(request));
-  }
-
-  std::string next_expected_string_;
-  int num_messages_received_ = 0;
-  bool received_quit_ = false;
-
-  mojo::AssociatedBinding<IPC::mojom::SimpleTestDriver> binding_;
-};
-
-const int ListenerWithSimpleAssociatedInterface::kNumMessages = 1000;
-
-class ListenerSendingAssociatedMessages : public IPC::Listener {
- public:
-  ListenerSendingAssociatedMessages() {}
-
-  bool OnMessageReceived(const IPC::Message& message) override { return true; }
-
-  void OnChannelConnected(int32_t peer_pid) override {
-    DCHECK(channel_);
-    channel_->GetAssociatedInterfaceSupport()->GetRemoteAssociatedInterface(
-        &driver_);
-
-    // Send a bunch of interleaved messages, alternating between the associated
-    // interface and a legacy IPC::Message.
-    for (int i = 0; i < ListenerWithSimpleAssociatedInterface::kNumMessages;
-         ++i) {
-      std::string str = base::StringPrintf("Hello! %d", i);
-      driver_->ExpectString(str);
-      SendString(channel_, str);
-    }
-    driver_->RequestQuit(base::Bind(&OnQuitAck));
-  }
-
-  void set_channel(IPC::Channel* channel) { channel_ = channel; }
-
- private:
-  static void OnQuitAck() { base::MessageLoop::current()->QuitWhenIdle(); }
-
-  IPC::Channel* channel_ = nullptr;
-  IPC::mojom::SimpleTestDriverAssociatedPtr driver_;
-};
-
-TEST_F(IPCChannelMojoTest, SimpleAssociatedInterface) {
-  InitWithMojo("SimpleAssociatedInterfaceClient");
-
-  ListenerWithSimpleAssociatedInterface listener;
-  CreateChannel(&listener);
-  ASSERT_TRUE(ConnectChannel());
-
-  listener.RegisterInterfaceFactory(channel());
-
-  base::RunLoop().Run();
-  channel()->Close();
-
-  EXPECT_TRUE(WaitForClientShutdown());
-  DestroyChannel();
-}
-
-DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(SimpleAssociatedInterfaceClient,
-                                    ChannelClient) {
-  ListenerSendingAssociatedMessages listener;
-  Connect(&listener);
-  listener.set_channel(channel());
-
-  base::RunLoop().Run();
-
-  Close();
-}
-
 #if defined(OS_POSIX)
 class ListenerThatExpectsFile : public IPC::Listener {
  public:
   ListenerThatExpectsFile() : sender_(NULL) {}
 
   ~ListenerThatExpectsFile() override {}
 
   bool OnMessageReceived(const IPC::Message& message) override {
     base::PickleIterator iter(message);
     HandleSendingHelper::ReadReceivedFile(message, &iter);
@@ skipping 94 matching lines @@
     ChannelClient) {
   ListenerThatExpectsFileAndPipe listener;
   Connect(&listener);
   listener.set_sender(channel());
 
   base::RunLoop().Run();
 
   Close();
 }
 
-#endif  // defined(OS_POSIX)
+#endif
 
 #if defined(OS_LINUX)
 
 const base::ProcessId kMagicChildId = 54321;
 
 class ListenerThatVerifiesPeerPid : public IPC::Listener {
  public:
   void OnChannelConnected(int32_t peer_pid) override {
     EXPECT_EQ(peer_pid, kMagicChildId);
     base::MessageLoop::current()->QuitWhenIdle();
@@ skipping 26 matching lines @@
   Connect(&listener);
 
   base::MessageLoop::current()->Run();
 
   Close();
 }
 
 #endif  // OS_LINUX
 
 }  // namespace