Implement IPC::ChannelFactory, a class that accept()s on a UNIX socket.

ipc/ipc_channel_posix_unittest.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.
 
 // These tests are POSIX only.
 
 #include "ipc/ipc_channel_posix.h"
 
 #include <fcntl.h>
 #include <sys/socket.h>
 #include <sys/un.h>
 #include <unistd.h>
 
 #include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/test/multiprocess_test.h"
 #include "base/test/test_timeouts.h"
 #include "ipc/ipc_listener.h"
+#include "ipc/unix_domain_socket_util.h"
 #include "testing/multiprocess_func_list.h"
 
 namespace {
 
 static const uint32 kQuitMessage = 47;
 
 class IPCChannelPosixTestListener : public IPC::Listener {
  public:
   enum STATUS {
     DISCONNECTED,
@@ skipping 104 matching lines @@
 void IPCChannelPosixTest::SetUpSocket(IPC::ChannelHandle *handle,
                                       IPC::Channel::Mode mode) {
   const std::string& name = handle->name;
 
   int socket_fd = socket(PF_UNIX, SOCK_STREAM, 0);
   ASSERT_GE(socket_fd, 0) << name;
   ASSERT_GE(fcntl(socket_fd, F_SETFL, O_NONBLOCK), 0);
   struct sockaddr_un server_address = { 0 };
   memset(&server_address, 0, sizeof(server_address));
   server_address.sun_family = AF_UNIX;
-  int path_len = snprintf(server_address.sun_path, IPC::kMaxPipeNameLength,
+  int path_len = snprintf(server_address.sun_path, IPC::kMaxSocketNameLength,
                           "%s", name.c_str());
   DCHECK_EQ(static_cast<int>(name.length()), path_len);
   size_t server_address_len = offsetof(struct sockaddr_un,
                                        sun_path) + path_len + 1;
 
   if (mode == IPC::Channel::MODE_NAMED_SERVER) {
     // Only one server at a time. Cleanup garbage if it exists.
     unlink(name.c_str());
     // Make sure the path we need exists.
     base::FilePath path(name);
@@ skipping 145 matching lines @@
   ASSERT_FALSE(channel.Connect());
 
   // Test name that is too long.
   const char *kTooLongName = "This_is_a_very_long_name_to_proactively_implement"
                              "client-centered_synergy_through_top-line"
                              "platforms_Phosfluorescently_disintermediate_"
                              "clicks-and-mortar_best_practices_without_"
                              "future-proof_growth_strategies_Continually"
                              "pontificate_proactive_potentialities_before"
                              "leading-edge_processes";
-  EXPECT_GE(strlen(kTooLongName), IPC::kMaxPipeNameLength);
+  EXPECT_GE(strlen(kTooLongName), IPC::kMaxSocketNameLength);
   IPC::ChannelHandle handle2(kTooLongName);
   IPC::Channel channel2(handle2, IPC::Channel::MODE_NAMED_SERVER, NULL);
   EXPECT_FALSE(channel2.Connect());
 }
 
 TEST_F(IPCChannelPosixTest, MultiConnection) {
   // Test setting up a connection to an external process, and then have
   // another external process attempt to connect to us.
   IPCChannelPosixTestListener listener(false);
   IPC::ChannelHandle chan_handle(GetConnectionSocketName());
@@ skipping 93 matching lines @@
   if (connected) {
     IPCChannelPosixTest::SpinRunLoop(TestTimeouts::action_max_timeout());
     EXPECT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, listener.status());
   } else {
     EXPECT_EQ(IPCChannelPosixTestListener::DISCONNECTED, listener.status());
   }
   return 0;
 }
 
 }  // namespace