ipc/ipc_channel_posix_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // These tests are POSIX only.
   6
   7 #include "ipc/ipc_channel_posix.h"
   8
   9 #include <fcntl.h>
  10 #include <sys/socket.h>
  11 #include <sys/un.h>
  12 #include <unistd.h>
  13
  14 #include "base/basictypes.h"
  15 #include "base/files/file_path.h"
  16 #include "base/files/file_util.h"
  17 #include "base/memory/scoped_ptr.h"
  18 #include "base/message_loop/message_loop.h"
  19 #include "base/path_service.h"
  20 #include "base/posix/eintr_wrapper.h"
  21 #include "base/process/kill.h"
  22 #include "base/test/multiprocess_test.h"
  23 #include "base/test/test_timeouts.h"
  24 #include "ipc/ipc_listener.h"
  25 #include "ipc/unix_domain_socket_util.h"
  26 #include "testing/multiprocess_func_list.h"
  27
  28 namespace {
  29
  30 static const uint32 kQuitMessage = 47;
  31
  32 class IPCChannelPosixTestListener : public IPC::Listener {
  33  public:
  34   enum STATUS {
  35     DISCONNECTED,
  36     MESSAGE_RECEIVED,
  37     CHANNEL_ERROR,
  38     CONNECTED,
  39     DENIED,
  40     LISTEN_ERROR
  41   };
  42
  43   IPCChannelPosixTestListener(bool quit_only_on_message)
  44       : status_(DISCONNECTED),
  45         quit_only_on_message_(quit_only_on_message) {
  46   }
  47
  48   virtual ~IPCChannelPosixTestListener() {}
  49
  50   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
  51     EXPECT_EQ(message.type(), kQuitMessage);
  52     status_ = MESSAGE_RECEIVED;
  53     QuitRunLoop();
  54     return true;
  55   }
  56
  57   virtual void OnChannelConnected(int32 peer_pid) OVERRIDE {
  58     status_ = CONNECTED;
  59     if (!quit_only_on_message_) {
  60       QuitRunLoop();
  61     }
  62   }
  63
  64   virtual void OnChannelError() OVERRIDE {
  65     status_ = CHANNEL_ERROR;
  66     QuitRunLoop();
  67   }
  68
  69   virtual void OnChannelDenied() OVERRIDE {
  70     status_ = DENIED;
  71     if (!quit_only_on_message_) {
  72       QuitRunLoop();
  73     }
  74   }
  75
  76   virtual void OnChannelListenError() OVERRIDE {
  77     status_ = LISTEN_ERROR;
  78     if (!quit_only_on_message_) {
  79       QuitRunLoop();
  80     }
  81   }
  82
  83   STATUS status() { return status_; }
  84
  85   void QuitRunLoop() {
  86     base::MessageLoopForIO* loop = base::MessageLoopForIO::current();
  87     if (loop->is_running()) {
  88       loop->QuitNow();
  89     } else {
  90       // Die as soon as Run is called.
  91       loop->PostTask(FROM_HERE, loop->QuitClosure());
  92     }
  93   }
  94
  95  private:
  96   // The current status of the listener.
  97   STATUS status_;
  98   // If |quit_only_on_message_| then the listener will only break out of
  99   // the run loop when kQuitMessage is received.
 100   bool quit_only_on_message_;
 101 };
 102
 103 class IPCChannelPosixTest : public base::MultiProcessTest {
 104  public:
 105   static void SetUpSocket(IPC::ChannelHandle *handle,
 106                           IPC::Channel::Mode mode);
 107   static void SpinRunLoop(base::TimeDelta delay);
 108   static const std::string GetConnectionSocketName();
 109   static const std::string GetChannelDirName();
 110
 111  protected:
 112   virtual void SetUp();
 113   virtual void TearDown();
 114
 115  private:
 116   scoped_ptr<base::MessageLoopForIO> message_loop_;
 117 };
 118
 119 const std::string IPCChannelPosixTest::GetChannelDirName() {
 120 #if defined(OS_ANDROID)
 121   base::FilePath tmp_dir;
 122   PathService::Get(base::DIR_CACHE, &tmp_dir);
 123   return tmp_dir.value();
 124 #else
 125   return "/var/tmp";
 126 #endif
 127 }
 128
 129 const std::string IPCChannelPosixTest::GetConnectionSocketName() {
 130   return GetChannelDirName() + "/chrome_IPCChannelPosixTest__ConnectionSocket";
 131 }
 132
 133 void IPCChannelPosixTest::SetUp() {
 134   MultiProcessTest::SetUp();
 135   // Construct a fresh IO Message loop for the duration of each test.
 136   message_loop_.reset(new base::MessageLoopForIO());
 137 }
 138
 139 void IPCChannelPosixTest::TearDown() {
 140   message_loop_.reset(NULL);
 141   MultiProcessTest::TearDown();
 142 }
 143
 144 // Create up a socket and bind and listen to it, or connect it
 145 // depending on the |mode|.
 146 void IPCChannelPosixTest::SetUpSocket(IPC::ChannelHandle *handle,
 147                                       IPC::Channel::Mode mode) {
 148   const std::string& name = handle->name;
 149
 150   int socket_fd = socket(PF_UNIX, SOCK_STREAM, 0);
 151   ASSERT_GE(socket_fd, 0) << name;
 152   ASSERT_GE(fcntl(socket_fd, F_SETFL, O_NONBLOCK), 0);
 153   struct sockaddr_un server_address = { 0 };
 154   memset(&server_address, 0, sizeof(server_address));
 155   server_address.sun_family = AF_UNIX;
 156   int path_len = snprintf(server_address.sun_path, IPC::kMaxSocketNameLength,
 157                           "%s", name.c_str());
 158   DCHECK_EQ(static_cast<int>(name.length()), path_len);
 159   size_t server_address_len = offsetof(struct sockaddr_un,
 160                                        sun_path) + path_len + 1;
 161
 162   if (mode == IPC::Channel::MODE_NAMED_SERVER) {
 163     // Only one server at a time. Cleanup garbage if it exists.
 164     unlink(name.c_str());
 165     // Make sure the path we need exists.
 166     base::FilePath path(name);
 167     base::FilePath dir_path = path.DirName();
 168     ASSERT_TRUE(base::CreateDirectory(dir_path));
 169     ASSERT_GE(bind(socket_fd,
 170                    reinterpret_cast<struct sockaddr *>(&server_address),
 171                    server_address_len), 0) << server_address.sun_path
 172                                            << ": " << strerror(errno)
 173                                            << "(" << errno << ")";
 174     ASSERT_GE(listen(socket_fd, SOMAXCONN), 0) << server_address.sun_path
 175                                                << ": " << strerror(errno)
 176                                                << "(" << errno << ")";
 177   } else if (mode == IPC::Channel::MODE_NAMED_CLIENT) {
 178     ASSERT_GE(connect(socket_fd,
 179                       reinterpret_cast<struct sockaddr *>(&server_address),
 180                       server_address_len), 0) << server_address.sun_path
 181                                               << ": " << strerror(errno)
 182                                               << "(" << errno << ")";
 183   } else {
 184     FAIL() << "Unknown mode " << mode;
 185   }
 186   handle->socket.fd = socket_fd;
 187 }
 188
 189 void IPCChannelPosixTest::SpinRunLoop(base::TimeDelta delay) {
 190   base::MessageLoopForIO* loop = base::MessageLoopForIO::current();
 191   // Post a quit task so that this loop eventually ends and we don't hang
 192   // in the case of a bad test. Usually, the run loop will quit sooner than
 193   // that because all tests use a IPCChannelPosixTestListener which quits the
 194   // current run loop on any channel activity.
 195   loop->PostDelayedTask(FROM_HERE, loop->QuitClosure(), delay);
 196   loop->Run();
 197 }
 198
 199 TEST_F(IPCChannelPosixTest, BasicListen) {
 200   const std::string kChannelName =
 201       GetChannelDirName() + "/IPCChannelPosixTest_BasicListen";
 202
 203   // Test creating a socket that is listening.
 204   IPC::ChannelHandle handle(kChannelName);
 205   SetUpSocket(&handle, IPC::Channel::MODE_NAMED_SERVER);
 206   unlink(handle.name.c_str());
 207   scoped_ptr<IPC::ChannelPosix> channel(
 208       new IPC::ChannelPosix(handle, IPC::Channel::MODE_NAMED_SERVER, NULL));
 209   ASSERT_TRUE(channel->Connect());
 210   ASSERT_TRUE(channel->AcceptsConnections());
 211   ASSERT_FALSE(channel->HasAcceptedConnection());
 212   channel->ResetToAcceptingConnectionState();
 213   ASSERT_FALSE(channel->HasAcceptedConnection());
 214 }
 215
 216 TEST_F(IPCChannelPosixTest, BasicConnected) {
 217   // Test creating a socket that is connected.
 218   int pipe_fds[2];
 219   ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, pipe_fds));
 220   std::string socket_name("/var/tmp/IPCChannelPosixTest_BasicConnected");
 221   ASSERT_GE(fcntl(pipe_fds[0], F_SETFL, O_NONBLOCK), 0);
 222
 223   base::FileDescriptor fd(pipe_fds[0], false);
 224   IPC::ChannelHandle handle(socket_name, fd);
 225   scoped_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
 226       handle, IPC::Channel::MODE_SERVER, NULL));
 227   ASSERT_TRUE(channel->Connect());
 228   ASSERT_FALSE(channel->AcceptsConnections());
 229   channel->Close();
 230   ASSERT_TRUE(IGNORE_EINTR(close(pipe_fds[1])) == 0);
 231
 232   // Make sure that we can use the socket that is created for us by
 233   // a standard channel.
 234   scoped_ptr<IPC::ChannelPosix> channel2(new IPC::ChannelPosix(
 235       socket_name, IPC::Channel::MODE_SERVER, NULL));
 236   ASSERT_TRUE(channel2->Connect());
 237   ASSERT_FALSE(channel2->AcceptsConnections());
 238 }
 239
 240 // If a connection closes right before a Send() call, we may end up closing
 241 // the connection without notifying the listener, which can cause hangs in
 242 // sync_message_filter and others. Make sure the listener is notified.
 243 TEST_F(IPCChannelPosixTest, SendHangTest) {
 244   IPCChannelPosixTestListener out_listener(true);
 245   IPCChannelPosixTestListener in_listener(true);
 246   IPC::ChannelHandle in_handle("IN");
 247   scoped_ptr<IPC::ChannelPosix> in_chan(new IPC::ChannelPosix(
 248       in_handle, IPC::Channel::MODE_SERVER, &in_listener));
 249   base::FileDescriptor out_fd(
 250       in_chan->TakeClientFileDescriptor(), false);
 251   IPC::ChannelHandle out_handle("OUT", out_fd);
 252   scoped_ptr<IPC::ChannelPosix> out_chan(new IPC::ChannelPosix(
 253       out_handle, IPC::Channel::MODE_CLIENT, &out_listener));
 254   ASSERT_TRUE(in_chan->Connect());
 255   ASSERT_TRUE(out_chan->Connect());
 256   in_chan->Close();  // simulate remote process dying at an unfortunate time.
 257   // Send will fail, because it cannot write the message.
 258   ASSERT_FALSE(out_chan->Send(new IPC::Message(
 259       0,  // routing_id
 260       kQuitMessage,  // message type
 261       IPC::Message::PRIORITY_NORMAL)));
 262   SpinRunLoop(TestTimeouts::action_max_timeout());
 263   ASSERT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, out_listener.status());
 264 }
 265
 266 // If a connection closes right before a Connect() call, we may end up closing
 267 // the connection without notifying the listener, which can cause hangs in
 268 // sync_message_filter and others. Make sure the listener is notified.
 269 TEST_F(IPCChannelPosixTest, AcceptHangTest) {
 270   IPCChannelPosixTestListener out_listener(true);
 271   IPCChannelPosixTestListener in_listener(true);
 272   IPC::ChannelHandle in_handle("IN");
 273   scoped_ptr<IPC::ChannelPosix> in_chan(new IPC::ChannelPosix(
 274       in_handle, IPC::Channel::MODE_SERVER, &in_listener));
 275   base::FileDescriptor out_fd(
 276       in_chan->TakeClientFileDescriptor(), false);
 277   IPC::ChannelHandle out_handle("OUT", out_fd);
 278   scoped_ptr<IPC::ChannelPosix> out_chan(new IPC::ChannelPosix(
 279       out_handle, IPC::Channel::MODE_CLIENT, &out_listener));
 280   ASSERT_TRUE(in_chan->Connect());
 281   in_chan->Close();  // simulate remote process dying at an unfortunate time.
 282   ASSERT_FALSE(out_chan->Connect());
 283   SpinRunLoop(TestTimeouts::action_max_timeout());
 284   ASSERT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, out_listener.status());
 285 }
 286
 287 TEST_F(IPCChannelPosixTest, AdvancedConnected) {
 288   // Test creating a connection to an external process.
 289   IPCChannelPosixTestListener listener(false);
 290   IPC::ChannelHandle chan_handle(GetConnectionSocketName());
 291   SetUpSocket(&chan_handle, IPC::Channel::MODE_NAMED_SERVER);
 292   scoped_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
 293       chan_handle, IPC::Channel::MODE_NAMED_SERVER, &listener));
 294   ASSERT_TRUE(channel->Connect());
 295   ASSERT_TRUE(channel->AcceptsConnections());
 296   ASSERT_FALSE(channel->HasAcceptedConnection());
 297
 298   base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc");
 299   ASSERT_TRUE(handle);
 300   SpinRunLoop(TestTimeouts::action_max_timeout());
 301   ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
 302   ASSERT_TRUE(channel->HasAcceptedConnection());
 303   IPC::Message* message = new IPC::Message(0,  // routing_id
 304                                            kQuitMessage,  // message type
 305                                            IPC::Message::PRIORITY_NORMAL);
 306   channel->Send(message);
 307   SpinRunLoop(TestTimeouts::action_timeout());
 308   int exit_code = 0;
 309   EXPECT_TRUE(base::WaitForExitCode(handle, &exit_code));
 310   EXPECT_EQ(0, exit_code);
 311   ASSERT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, listener.status());
 312   ASSERT_FALSE(channel->HasAcceptedConnection());
 313 }
 314
 315 TEST_F(IPCChannelPosixTest, ResetState) {
 316   // Test creating a connection to an external process. Close the connection,
 317   // but continue to listen and make sure another external process can connect
 318   // to us.
 319   IPCChannelPosixTestListener listener(false);
 320   IPC::ChannelHandle chan_handle(GetConnectionSocketName());
 321   SetUpSocket(&chan_handle, IPC::Channel::MODE_NAMED_SERVER);
 322   scoped_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
 323       chan_handle, IPC::Channel::MODE_NAMED_SERVER, &listener));
 324   ASSERT_TRUE(channel->Connect());
 325   ASSERT_TRUE(channel->AcceptsConnections());
 326   ASSERT_FALSE(channel->HasAcceptedConnection());
 327
 328   base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc");
 329   ASSERT_TRUE(handle);
 330   SpinRunLoop(TestTimeouts::action_max_timeout());
 331   ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
 332   ASSERT_TRUE(channel->HasAcceptedConnection());
 333   channel->ResetToAcceptingConnectionState();
 334   ASSERT_FALSE(channel->HasAcceptedConnection());
 335
 336   base::ProcessHandle handle2 = SpawnChild("IPCChannelPosixTestConnectionProc");
 337   ASSERT_TRUE(handle2);
 338   SpinRunLoop(TestTimeouts::action_max_timeout());
 339   ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
 340   ASSERT_TRUE(channel->HasAcceptedConnection());
 341   IPC::Message* message = new IPC::Message(0,  // routing_id
 342                                            kQuitMessage,  // message type
 343                                            IPC::Message::PRIORITY_NORMAL);
 344   channel->Send(message);
 345   SpinRunLoop(TestTimeouts::action_timeout());
 346   EXPECT_TRUE(base::KillProcess(handle, 0, false));
 347   int exit_code = 0;
 348   EXPECT_TRUE(base::WaitForExitCode(handle2, &exit_code));
 349   EXPECT_EQ(0, exit_code);
 350   ASSERT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, listener.status());
 351   ASSERT_FALSE(channel->HasAcceptedConnection());
 352 }
 353
 354 TEST_F(IPCChannelPosixTest, BadChannelName) {
 355   // Test empty name
 356   IPC::ChannelHandle handle("");
 357   scoped_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
 358       handle, IPC::Channel::MODE_NAMED_SERVER, NULL));
 359   ASSERT_FALSE(channel->Connect());
 360
 361   // Test name that is too long.
 362   const char *kTooLongName = "This_is_a_very_long_name_to_proactively_implement"
 363                              "client-centered_synergy_through_top-line"
 364                              "platforms_Phosfluorescently_disintermediate_"
 365                              "clicks-and-mortar_best_practices_without_"
 366                              "future-proof_growth_strategies_Continually"
 367                              "pontificate_proactive_potentialities_before"
 368                              "leading-edge_processes";
 369   EXPECT_GE(strlen(kTooLongName), IPC::kMaxSocketNameLength);
 370   IPC::ChannelHandle handle2(kTooLongName);
 371   scoped_ptr<IPC::ChannelPosix> channel2(new IPC::ChannelPosix(
 372       handle2, IPC::Channel::MODE_NAMED_SERVER, NULL));
 373   EXPECT_FALSE(channel2->Connect());
 374 }
 375
 376 TEST_F(IPCChannelPosixTest, MultiConnection) {
 377   // Test setting up a connection to an external process, and then have
 378   // another external process attempt to connect to us.
 379   IPCChannelPosixTestListener listener(false);
 380   IPC::ChannelHandle chan_handle(GetConnectionSocketName());
 381   SetUpSocket(&chan_handle, IPC::Channel::MODE_NAMED_SERVER);
 382   scoped_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
 383       chan_handle, IPC::Channel::MODE_NAMED_SERVER, &listener));
 384   ASSERT_TRUE(channel->Connect());
 385   ASSERT_TRUE(channel->AcceptsConnections());
 386   ASSERT_FALSE(channel->HasAcceptedConnection());
 387
 388   base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc");
 389   ASSERT_TRUE(handle);
 390   SpinRunLoop(TestTimeouts::action_max_timeout());
 391   ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
 392   ASSERT_TRUE(channel->HasAcceptedConnection());
 393   base::ProcessHandle handle2 = SpawnChild("IPCChannelPosixFailConnectionProc");
 394   ASSERT_TRUE(handle2);
 395   SpinRunLoop(TestTimeouts::action_max_timeout());
 396   int exit_code = 0;
 397   EXPECT_TRUE(base::WaitForExitCode(handle2, &exit_code));
 398   EXPECT_EQ(exit_code, 0);
 399   ASSERT_EQ(IPCChannelPosixTestListener::DENIED, listener.status());
 400   ASSERT_TRUE(channel->HasAcceptedConnection());
 401   IPC::Message* message = new IPC::Message(0,  // routing_id
 402                                            kQuitMessage,  // message type
 403                                            IPC::Message::PRIORITY_NORMAL);
 404   channel->Send(message);
 405   SpinRunLoop(TestTimeouts::action_timeout());
 406   EXPECT_TRUE(base::WaitForExitCode(handle, &exit_code));
 407   EXPECT_EQ(exit_code, 0);
 408   ASSERT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, listener.status());
 409   ASSERT_FALSE(channel->HasAcceptedConnection());
 410 }
 411
 412 TEST_F(IPCChannelPosixTest, DoubleServer) {
 413   // Test setting up two servers with the same name.
 414   IPCChannelPosixTestListener listener(false);
 415   IPCChannelPosixTestListener listener2(false);
 416   IPC::ChannelHandle chan_handle(GetConnectionSocketName());
 417   scoped_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
 418       chan_handle, IPC::Channel::MODE_SERVER, &listener));
 419   scoped_ptr<IPC::ChannelPosix> channel2(new IPC::ChannelPosix(
 420       chan_handle, IPC::Channel::MODE_SERVER, &listener2));
 421   ASSERT_TRUE(channel->Connect());
 422   ASSERT_FALSE(channel2->Connect());
 423 }
 424
 425 TEST_F(IPCChannelPosixTest, BadMode) {
 426   // Test setting up two servers with a bad mode.
 427   IPCChannelPosixTestListener listener(false);
 428   IPC::ChannelHandle chan_handle(GetConnectionSocketName());
 429   scoped_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
 430       chan_handle, IPC::Channel::MODE_NONE, &listener));
 431   ASSERT_FALSE(channel->Connect());
 432 }
 433
 434 TEST_F(IPCChannelPosixTest, IsNamedServerInitialized) {
 435   const std::string& connection_socket_name = GetConnectionSocketName();
 436   IPCChannelPosixTestListener listener(false);
 437   IPC::ChannelHandle chan_handle(connection_socket_name);
 438   ASSERT_TRUE(base::DeleteFile(base::FilePath(connection_socket_name), false));
 439   ASSERT_FALSE(IPC::Channel::IsNamedServerInitialized(
 440       connection_socket_name));
 441   scoped_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
 442       chan_handle, IPC::Channel::MODE_NAMED_SERVER, &listener));
 443   ASSERT_TRUE(IPC::Channel::IsNamedServerInitialized(
 444       connection_socket_name));
 445   channel->Close();
 446   ASSERT_FALSE(IPC::Channel::IsNamedServerInitialized(
 447       connection_socket_name));
 448 }
 449
 450 // A long running process that connects to us
 451 MULTIPROCESS_TEST_MAIN(IPCChannelPosixTestConnectionProc) {
 452   base::MessageLoopForIO message_loop;
 453   IPCChannelPosixTestListener listener(true);
 454   IPC::ChannelHandle handle(IPCChannelPosixTest::GetConnectionSocketName());
 455   IPCChannelPosixTest::SetUpSocket(&handle, IPC::Channel::MODE_NAMED_CLIENT);
 456   scoped_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
 457       handle, IPC::Channel::MODE_NAMED_CLIENT, &listener));
 458   EXPECT_TRUE(channel->Connect());
 459   IPCChannelPosixTest::SpinRunLoop(TestTimeouts::action_max_timeout());
 460   EXPECT_EQ(IPCChannelPosixTestListener::MESSAGE_RECEIVED, listener.status());
 461   return 0;
 462 }
 463
 464 // Simple external process that shouldn't be able to connect to us.
 465 MULTIPROCESS_TEST_MAIN(IPCChannelPosixFailConnectionProc) {
 466   base::MessageLoopForIO message_loop;
 467   IPCChannelPosixTestListener listener(false);
 468   IPC::ChannelHandle handle(IPCChannelPosixTest::GetConnectionSocketName());
 469   IPCChannelPosixTest::SetUpSocket(&handle, IPC::Channel::MODE_NAMED_CLIENT);
 470   scoped_ptr<IPC::ChannelPosix> channel(new IPC::ChannelPosix(
 471       handle, IPC::Channel::MODE_NAMED_CLIENT, &listener));
 472
 473   // In this case connect may succeed or fail depending on if the packet
 474   // actually gets sent at sendmsg. Since we never delay on send, we may not
 475   // see the error. However even if connect succeeds, eventually we will get an
 476   // error back since the channel will be closed when we attempt to read from
 477   // it.
 478   bool connected = channel->Connect();
 479   if (connected) {
 480     IPCChannelPosixTest::SpinRunLoop(TestTimeouts::action_max_timeout());
 481     EXPECT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, listener.status());
 482   } else {
 483     EXPECT_EQ(IPCChannelPosixTestListener::DISCONNECTED, listener.status());
 484   }
 485   return 0;
 486 }
 487
 488 }  // namespace