IPC: Add MojoHandleAttachment

ipc/mojo/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/mojo/ipc_channel_mojo.h"
 
 #include "base/base_paths.h"
 #include "base/files/file.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/pickle.h"
 #include "base/threading/thread.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_test_base.h"
 #include "ipc/ipc_test_channel_listener.h"
 #include "ipc/mojo/ipc_channel_mojo_host.h"
+#include "ipc/mojo/ipc_mojo_handle_attachment.h"
+#include "ipc/mojo/ipc_mojo_message_helper.h"
 
 #if defined(OS_POSIX)
 #include "base/file_descriptor_posix.h"
 #include "ipc/ipc_platform_file_attachment_posix.h"
 #endif
 
 namespace {
 
 class ListenerThatExpectsOK : public IPC::Listener {
  public:
@@ skipping 223 matching lines @@
   base::MessageLoop::current()->Run();
 
   this->channel()->Close();
 
   EXPECT_TRUE(WaitForClientShutdown());
   EXPECT_TRUE(listener.has_error());
 
   DestroyChannel();
 }
 
+struct TestingMessagePipe {
+  TestingMessagePipe() {
+    EXPECT_EQ(MOJO_RESULT_OK, mojo::CreateMessagePipe(nullptr, &self, &peer));
+  }
+
+  mojo::ScopedMessagePipeHandle self;
+  mojo::ScopedMessagePipeHandle peer;
+};
+
+class HandleSendingHelper {
+ public:
+  static std::string GetSendingFileContent() { return "Hello"; }
+
+  static void WritePipe(IPC::Message* message, TestingMessagePipe* pipe) {
+    std::string content = HandleSendingHelper::GetSendingFileContent();
+    EXPECT_EQ(MOJO_RESULT_OK,
+              mojo::WriteMessageRaw(pipe->self.get(), &content[0],
+                                    content.size(), nullptr, 0, 0));
+    EXPECT_TRUE(
+        IPC::MojoMessageHelper::WriteMessagePipeTo(message, pipe->peer.Pass()));
+  }
+
+  static void WritePipeThenSend(IPC::Sender* sender, TestingMessagePipe* pipe) {
+    IPC::Message* message =
+        new IPC::Message(0, 2, IPC::Message::PRIORITY_NORMAL);
+    WritePipe(message, pipe);
+    ASSERT_TRUE(sender->Send(message));
+  }
+
+  static void ReadReceivedPipe(const IPC::Message& message,
+                               PickleIterator* iter) {
+    mojo::ScopedMessagePipeHandle pipe;
+    EXPECT_TRUE(
+        IPC::MojoMessageHelper::ReadMessagePipeFrom(&message, iter, &pipe));
+    std::string content(GetSendingFileContent().size(), ' ');
+
+    uint32_t num_bytes = content.size();
+    EXPECT_EQ(MOJO_RESULT_OK,
+              mojo::ReadMessageRaw(pipe.get(), &content[0], &num_bytes, nullptr,
+                                   nullptr, 0));
+    EXPECT_EQ(content, GetSendingFileContent());
+  }
+
+#if defined(OS_POSIX)
+  static base::FilePath GetSendingFilePath() {
+    base::FilePath path;
+    bool ok = PathService::Get(base::DIR_CACHE, &path);
+    EXPECT_TRUE(ok);
+    return path.Append("ListenerThatExpectsFile.txt");
+  }
+
+  static void WriteFile(IPC::Message* message, base::File& file) {
+    std::string content = GetSendingFileContent();
+    file.WriteAtCurrentPos(content.data(), content.size());
+    file.Flush();
+    message->WriteAttachment(new IPC::internal::PlatformFileAttachment(
+        base::ScopedFD(file.TakePlatformFile())));
+  }
+
+  static void WriteFileThenSend(IPC::Sender* sender, base::File& file) {
+    IPC::Message* message =
+        new IPC::Message(0, 2, IPC::Message::PRIORITY_NORMAL);
+    WriteFile(message, file);
+    ASSERT_TRUE(sender->Send(message));
+  }
+
+  static void WriteFileAndPipeThenSend(IPC::Sender* sender,
+                                       base::File& file,
+                                       TestingMessagePipe* pipe) {
+    IPC::Message* message =
+        new IPC::Message(0, 2, IPC::Message::PRIORITY_NORMAL);
+    WriteFile(message, file);
+    WritePipe(message, pipe);
+    ASSERT_TRUE(sender->Send(message));
+  }
+
+  static void ReadReceivedFile(const IPC::Message& message,
+                               PickleIterator* iter) {
+    base::ScopedFD fd;
+    scoped_refptr<IPC::MessageAttachment> attachment;
+    EXPECT_TRUE(message.ReadAttachment(iter, &attachment));
+    base::File file(attachment->TakePlatformFile());
+    std::string content(GetSendingFileContent().size(), ' ');
+    file.Read(0, &content[0], content.size());
+    EXPECT_EQ(content, GetSendingFileContent());
+  }
+#endif
+};
+
+class ListenerThatExpectsMessagePipe : public IPC::Listener {
+ public:
+  ListenerThatExpectsMessagePipe() : sender_(NULL) {}
+
+  ~ListenerThatExpectsMessagePipe() override {}
+
+  bool OnMessageReceived(const IPC::Message& message) override {
+    PickleIterator iter(message);
+    HandleSendingHelper::ReadReceivedPipe(message, &iter);
+    base::MessageLoop::current()->Quit();
+    ListenerThatExpectsOK::SendOK(sender_);
+    return true;
+  }
+
+  void OnChannelError() override { NOTREACHED(); }
+
+  void set_sender(IPC::Sender* sender) { sender_ = sender; }
+
+ private:
+  IPC::Sender* sender_;
+};
+
+TEST_F(IPCChannelMojoTest, SendMessagePipe) {
+  Init("IPCChannelMojoTestSendMessagePipeClient");
+
+  ListenerThatExpectsOK listener;
+  CreateChannel(&listener);
+  ASSERT_TRUE(ConnectChannel());
+  ASSERT_TRUE(StartClient());
+
+  TestingMessagePipe pipe;
+  HandleSendingHelper::WritePipeThenSend(channel(), &pipe);
+
+  base::MessageLoop::current()->Run();
+  this->channel()->Close();
+
+  EXPECT_TRUE(WaitForClientShutdown());
+  DestroyChannel();
+}
+
+MULTIPROCESS_IPC_TEST_CLIENT_MAIN(IPCChannelMojoTestSendMessagePipeClient) {
+  ListenerThatExpectsMessagePipe listener;
+  ChannelClient client(&listener, "IPCChannelMojoTestSendPlatformHandleClient");
+  client.Connect();
+  listener.set_sender(client.channel());
+
+  base::MessageLoop::current()->Run();
+
+  return 0;
+}
+
 #if defined(OS_WIN)
 class IPCChannelMojoDeadHandleTest : public IPCTestBase {
  protected:
   virtual scoped_ptr<IPC::ChannelFactory> CreateChannelFactory(
       const IPC::ChannelHandle& handle,
       base::TaskRunner* runner) override {
     host_.reset(new IPC::ChannelMojoHost(task_runner()));
     return IPC::ChannelMojo::CreateServerFactory(host_->channel_delegate(),
                                                  handle);
   }
@@ skipping 50 matching lines @@
 #if defined(OS_POSIX)
 class ListenerThatExpectsFile : public IPC::Listener {
  public:
   ListenerThatExpectsFile()
       : sender_(NULL) {}
 
   ~ListenerThatExpectsFile() override {}
 
   bool OnMessageReceived(const IPC::Message& message) override {
     PickleIterator iter(message);
-
-    base::ScopedFD fd;
-    scoped_refptr<IPC::MessageAttachment> attachment;
-    EXPECT_TRUE(message.ReadAttachment(&iter, &attachment));
-    base::File file(attachment->TakePlatformFile());
-    std::string content(GetSendingFileContent().size(), ' ');
-    file.Read(0, &content[0], content.size());
-    EXPECT_EQ(content, GetSendingFileContent());
+    HandleSendingHelper::ReadReceivedFile(message, &iter);
     base::MessageLoop::current()->Quit();
     ListenerThatExpectsOK::SendOK(sender_);
     return true;
   }
 
   void OnChannelError() override {
     NOTREACHED();
   }
 
-  static std::string GetSendingFileContent() {
-    return "Hello";
-  }
-
-  static base::FilePath GetSendingFilePath() {
-    base::FilePath path;
-    bool ok = PathService::Get(base::DIR_CACHE, &path);
-    EXPECT_TRUE(ok);
-    return path.Append("ListenerThatExpectsFile.txt");
-  }
-
-  static void WriteAndSendFile(IPC::Sender* sender, base::File& file) {
-    std::string content = GetSendingFileContent();
-    file.WriteAtCurrentPos(content.data(), content.size());
-    file.Flush();
-    IPC::Message* message = new IPC::Message(
-        0, 2, IPC::Message::PRIORITY_NORMAL);
-    message->WriteAttachment(new IPC::internal::PlatformFileAttachment(
-        base::ScopedFD(file.TakePlatformFile())));
-    ASSERT_TRUE(sender->Send(message));
-  }
-
   void set_sender(IPC::Sender* sender) { sender_ = sender; }
 
  private:
   IPC::Sender* sender_;
 };
 
 
 TEST_F(IPCChannelMojoTest, SendPlatformHandle) {
   Init("IPCChannelMojoTestSendPlatformHandleClient");
 
   ListenerThatExpectsOK listener;
   CreateChannel(&listener);
   ASSERT_TRUE(ConnectChannel());
   ASSERT_TRUE(StartClient());
 
-  base::File file(ListenerThatExpectsFile::GetSendingFilePath(),
+  base::File file(HandleSendingHelper::GetSendingFilePath(),
                   base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE |
-                  base::File::FLAG_READ);
-  ListenerThatExpectsFile::WriteAndSendFile(channel(), file);
+                      base::File::FLAG_READ);
+  HandleSendingHelper::WriteFileThenSend(channel(), file);
   base::MessageLoop::current()->Run();
 
   this->channel()->Close();
 
   EXPECT_TRUE(WaitForClientShutdown());
   DestroyChannel();
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(IPCChannelMojoTestSendPlatformHandleClient) {
   ListenerThatExpectsFile listener;
   ChannelClient client(
       &listener, "IPCChannelMojoTestSendPlatformHandleClient");
   client.Connect();
   listener.set_sender(client.channel());
 
   base::MessageLoop::current()->Run();
 
   return 0;
 }
+
+class ListenerThatExpectsFileAndPipe : public IPC::Listener {
+ public:
+  ListenerThatExpectsFileAndPipe() : sender_(NULL) {}
+
+  ~ListenerThatExpectsFileAndPipe() override {}
+
+  bool OnMessageReceived(const IPC::Message& message) override {
+    PickleIterator iter(message);
+    HandleSendingHelper::ReadReceivedFile(message, &iter);
+    HandleSendingHelper::ReadReceivedPipe(message, &iter);
+    base::MessageLoop::current()->Quit();
+    ListenerThatExpectsOK::SendOK(sender_);
+    return true;
+  }
+
+  void OnChannelError() override { NOTREACHED(); }
+
+  void set_sender(IPC::Sender* sender) { sender_ = sender; }
+
+ private:
+  IPC::Sender* sender_;
+};
+
+TEST_F(IPCChannelMojoTest, SendPlatformHandleAndPipe) {
+  Init("IPCChannelMojoTestSendPlatformHandleAndPipeClient");
+
+  ListenerThatExpectsOK listener;
+  CreateChannel(&listener);
+  ASSERT_TRUE(ConnectChannel());
+  ASSERT_TRUE(StartClient());
+
+  base::File file(HandleSendingHelper::GetSendingFilePath(),
+                  base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE |
+                      base::File::FLAG_READ);
+  TestingMessagePipe pipe;
+  HandleSendingHelper::WriteFileAndPipeThenSend(channel(), file, &pipe);
+
+  base::MessageLoop::current()->Run();
+  this->channel()->Close();
+
+  EXPECT_TRUE(WaitForClientShutdown());
+  DestroyChannel();
+}
+
+MULTIPROCESS_IPC_TEST_CLIENT_MAIN(
+    IPCChannelMojoTestSendPlatformHandleAndPipeClient) {
+  ListenerThatExpectsFileAndPipe listener;
+  ChannelClient client(&listener,
+                       "IPCChannelMojoTestSendPlatformHandleAndPipeClient");
+  client.Connect();
+  listener.set_sender(client.channel());
+
+  base::MessageLoop::current()->Run();
+
+  return 0;
+}
+
 #endif
 
 }  // namespace