ipc_channel: warn if someone forgets to check the result of Connect()

ipc/ipc_tests.cc

 // Copyright (c) 2010 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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #elif defined(OS_POSIX)
 #include <sys/types.h>
@@ skipping 201 matching lines @@
  private:
   IPC::Message::Sender* sender_;
   int messages_left_;
 };
 
 TEST_F(IPCChannelTest, ChannelTest) {
   MyChannelListener channel_listener;
   // Setup IPC channel.
   IPC::Channel chan(kTestClientChannel, IPC::Channel::MODE_SERVER,
                     &channel_listener);
-  chan.Connect();
+  ASSERT_TRUE(chan.Connect());
 
   channel_listener.Init(&chan);
 
   base::ProcessHandle process_handle = SpawnChild(TEST_CLIENT, &chan);
   ASSERT_TRUE(process_handle);
 
   Send(&chan, "hello from parent");
 
   // Run message loop.
   MessageLoop::current()->Run();
@@ skipping 94 matching lines @@
 
 TEST_F(IPCChannelTest, SendMessageInChannelConnected) {
   // This tests the case of a listener sending back an event in it's
   // OnChannelConnected handler.
 
   ChannelListenerWithOnConnectedSend channel_listener;
   // Setup IPC channel.
   IPC::Channel channel(kTestClientChannel, IPC::Channel::MODE_SERVER,
                        &channel_listener);
   channel_listener.Init(&channel);
-  channel.Connect();
+  ASSERT_TRUE(channel.Connect());
 
   base::ProcessHandle process_handle = SpawnChild(TEST_CLIENT, &channel);
   ASSERT_TRUE(process_handle);
 
   Send(&channel, "hello from parent");
 
   // Run message loop.
   MessageLoop::current()->Run();
 
   // Close Channel so client gets its OnChannelError() callback fired.
   channel.Close();
 
   // Cleanup child process.
   EXPECT_TRUE(base::WaitForSingleProcess(process_handle, 5000));
   base::CloseProcessHandle(process_handle);
 }
 
 MULTIPROCESS_TEST_MAIN(RunTestClient) {
   MessageLoopForIO main_message_loop;
   MyChannelListener channel_listener;
 
   // setup IPC channel
   IPC::Channel chan(kTestClientChannel, IPC::Channel::MODE_CLIENT,
                     &channel_listener);
-  chan.Connect();
+  ASSERT_TRUE(chan.Connect());
   channel_listener.Init(&chan);
   Send(&chan, "hello from child");
   // run message loop
   MessageLoop::current()->Run();
   // return true;
   return NULL;
 }
 
 #endif  // !PERFORMANCE_TEST
 
@@ skipping 112 matching lines @@
   IPC::Channel *channel_;
   int count_messages_;
   int latency_messages_;
 };
 
 TEST_F(IPCChannelTest, Performance) {
   // setup IPC channel
   IPC::Channel chan(kReflectorChannel, IPC::Channel::MODE_SERVER, NULL);
   ChannelPerfListener perf_listener(&chan, 10000, 100000);
   chan.set_listener(&perf_listener);
-  chan.Connect();
+  ASSERT_TRUE(chan.Connect());
 
   HANDLE process = SpawnChild(TEST_REFLECTOR, &chan);
   ASSERT_TRUE(process);
 
   PlatformThread::Sleep(1000);
 
   PerfTimeLogger logger("IPC_Perf");
 
   // this initial message will kick-start the ping-pong of messages
   IPC::Message* message = new IPC::Message(0,
@@ skipping 11 matching lines @@
   WaitForSingleObject(process, 5000);
   CloseHandle(process);
 }
 
 // This message loop bounces all messages back to the sender
 MULTIPROCESS_TEST_MAIN(RunReflector) {
   MessageLoopForIO main_message_loop;
   IPC::Channel chan(kReflectorChannel, IPC::Channel::MODE_CLIENT, NULL);
   ChannelReflectorListener channel_reflector_listener(&chan);
   chan.set_listener(&channel_reflector_listener);
-  chan.Connect();
+  ASSERT_TRUE(chan.Connect());
 
   MessageLoop::current()->Run();
   return true;
 }
 
 #endif  // PERFORMANCE_TEST
 
 int main(int argc, char** argv) {
 #ifdef PERFORMANCE_TEST
   int retval = base::PerfTestSuite(argc, argv).Run();
 #else
   int retval = base::TestSuite(argc, argv).Run();
 #endif
   return retval;
 }