Capability: passing fds over IPC

chrome/common/ipc_tests.cc

 // Copyright (c) 2006-2008 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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 #include <stdio.h>
 #include <iostream>
 #include <string>
 
 #include "chrome/common/ipc_tests.h"
 
 #include "base/at_exit.h"
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/debug_on_start.h"
 #include "base/perftimer.h"
 #include "base/perf_test_suite.h"
 #include "base/test_suite.h"
 #include "base/thread.h"
 #include "chrome/common/chrome_switches.h"
+#if defined(OS_POSIX)
+#include "chrome/common/file_descriptor_posix.h"
+#endif
 #include "chrome/common/ipc_channel.h"
 #include "chrome/common/ipc_channel_proxy.h"
 #include "chrome/common/ipc_message_utils.h"
 #include "testing/multiprocess_func_list.h"
 
 // Define to enable IPC performance testing instead of the regular unit tests
 // #define PERFORMANCE_TEST
 
 const wchar_t kTestClientChannel[] = L"T1";
 const wchar_t kReflectorChannel[] = L"T2";
@@ skipping 53 matching lines @@
   }
 
   base::ProcessHandle ret = NULL;
   switch (child_type) {
   case TEST_CLIENT:
     ret = MultiProcessTest::SpawnChild(L"RunTestClient",
                                        fds_to_map,
                                        debug_on_start);
     channel->OnClientConnected();
     break;
+  case TEST_DESCRIPTOR_CLIENT:
+    ret = MultiProcessTest::SpawnChild(L"RunTestDescriptorClient",
+                                       fds_to_map,
+                                       debug_on_start);
+    channel->OnClientConnected();
+    break;
   case TEST_REFLECTOR:
     ret = MultiProcessTest::SpawnChild(L"RunReflector",
                                        fds_to_map,
                                        debug_on_start);
     channel->OnClientConnected();
     break;
   case FUZZER_SERVER:
     ret = MultiProcessTest::SpawnChild(L"RunFuzzServer",
                                        fds_to_map,
                                        debug_on_start);
@@ skipping 104 matching lines @@
   // Run message loop.
   MessageLoop::current()->Run();
 
   // Close Channel so client gets its OnChannelError() callback fired.
   chan.Close();
 
   // Cleanup child process.
   EXPECT_TRUE(base::WaitForSingleProcess(process_handle, 5000));
 }
 
+#if defined(OS_POSIX)
+
+class MyChannelDescriptorListener : public IPC::Channel::Listener {
+ public:
+  virtual void OnMessageReceived(const IPC::Message& message) {
+    void* iter = NULL;
+
+    FileDescriptor descriptor;
+
+    ASSERT_TRUE(
+        IPC::ParamTraits<FileDescriptor>::Read(&message, &iter, &descriptor));
+    VerifyDescriptor(&descriptor);
+    MessageLoop::current()->Quit();
+  }
+
+  virtual void OnChannelError() {
+    MessageLoop::current()->Quit();
+  }
+
+private:
+  static void VerifyDescriptor(FileDescriptor* descriptor) {
+    const int fd = open("/dev/null", O_RDONLY);
+    struct stat st1, st2;
+    fstat(fd, &st1);
+    close(fd);
+    fstat(descriptor->fd, &st2);
+    close(descriptor->fd);
+    ASSERT_EQ(st1.st_ino, st2.st_ino);
+  }
+};
+
+TEST_F(IPCChannelTest, DescriptorTest) {
+  // Setup IPC channel.
+  MyChannelDescriptorListener listener;
+
+  IPC::Channel chan(kTestClientChannel, IPC::Channel::MODE_SERVER,
+                    &listener);
+  chan.Connect();
+
+  base::ProcessHandle process_handle = SpawnChild(TEST_DESCRIPTOR_CLIENT,
+                                                  &chan);
+  ASSERT_TRUE(process_handle);
+
+  FileDescriptor descriptor;
+  const int fd = open("/dev/null", O_RDONLY);
+  ASSERT_GE(fd, 0);
+  descriptor.auto_close = true;
+  descriptor.fd = fd;
+
+  IPC::Message* message = new IPC::Message(0, // routing_id
+                                           3, // message type
+                                           IPC::Message::PRIORITY_NORMAL);
+  IPC::ParamTraits<FileDescriptor>::Write(message, descriptor);
+  chan.Send(message);
+
+  // Run message loop.
+  MessageLoop::current()->Run();
+
+  // Close Channel so client gets its OnChannelError() callback fired.
+  chan.Close();
+
+  // Cleanup child process.
+  EXPECT_TRUE(base::WaitForSingleProcess(process_handle, 5000));
+}
+
+MULTIPROCESS_TEST_MAIN(RunTestDescriptorClient) {
+  MessageLoopForIO main_message_loop;
+  MyChannelDescriptorListener listener;
+
+  // setup IPC channel
+  IPC::Channel chan(kTestClientChannel, IPC::Channel::MODE_CLIENT,
+                    &listener);
+  chan.Connect();
+
+  // run message loop
+  MessageLoop::current()->Run();
+  // return true;
+  return NULL;
+}
+
+#endif  // defined(OS_POSIX)
+
 TEST_F(IPCChannelTest, ChannelProxyTest) {
   // The thread needs to out-live the ChannelProxy.
   base::Thread thread("ChannelProxyTestServer");
   base::Thread::Options options;
   options.message_loop_type = MessageLoop::TYPE_IO;
   thread.StartWithOptions(options);
   {
     // setup IPC channel proxy
     IPC::ChannelProxy chan(kTestClientChannel, IPC::Channel::MODE_SERVER,
                            &channel_listener, NULL, thread.message_loop());
@@ skipping 40 matching lines @@
   IPC::Channel chan(kTestClientChannel, IPC::Channel::MODE_CLIENT,
                     &channel_listener);
   chan.Connect();
   channel_listener.Init(&chan);
   Send(&chan, "hello from child");
   // run message loop
   MessageLoop::current()->Run();
   // return true;
   return NULL;
 }
+
 #endif  // !PERFORMANCE_TEST
 
 #ifdef PERFORMANCE_TEST
 
 //-----------------------------------------------------------------------------
 // Manually performance test
 //
 //    This test times the roundtrip IPC message cycle. It is enabled with a
 //    special preprocessor define to enable it instead of the standard IPC
 //    unit tests. This works around some funny termination conditions in the
@@ skipping 152 matching lines @@
 #endif  // PERFORMANCE_TEST
 
 int main(int argc, char** argv) {
 #ifdef PERFORMANCE_TEST
   int retval = PerfTestSuite(argc, argv).Run();
 #else
   int retval = TestSuite(argc, argv).Run();
 #endif
   return retval;
 }