Switch to TimeDelta interfaces for process waiting functions in net and ipc.

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>
@@ skipping 80 matching lines @@
   // the run loop when kQuitMessage is received.
   bool quit_only_on_message_;
 };
 
 }  // namespace
 
 class IPCChannelPosixTest : public base::MultiProcessTest {
  public:
   static void SetUpSocket(IPC::ChannelHandle *handle,
                           IPC::Channel::Mode mode);
-  static void SpinRunLoop(int milliseconds);
+  static void SpinRunLoop(base::TimeDelta delay);
   static const std::string GetConnectionSocketName();
   static const std::string GetChannelDirName();
 
  protected:
   virtual void SetUp();
   virtual void TearDown();
 
 private:
   scoped_ptr<MessageLoopForIO> message_loop_;
 };
@@ skipping 61 matching lines @@
                       reinterpret_cast<struct sockaddr *>(&server_address),
                       server_address_len), 0) << server_address.sun_path
                                               << ": " << strerror(errno)
                                               << "(" << errno << ")";
   } else {
     FAIL() << "Unknown mode " << mode;
   }
   handle->socket.fd = socket_fd;
 }
 
-void IPCChannelPosixTest::SpinRunLoop(int milliseconds) {
+void IPCChannelPosixTest::SpinRunLoop(base::TimeDelta delay) {
   MessageLoopForIO *loop = MessageLoopForIO::current();
   // Post a quit task so that this loop eventually ends and we don't hang
   // in the case of a bad test. Usually, the run loop will quit sooner than
   // that because all tests use a IPCChannelPosixTestListener which quits the
   // current run loop on any channel activity.
   loop->PostDelayedTask(
       FROM_HERE,
       MessageLoop::QuitClosure(),
-      base::TimeDelta::FromMilliseconds(milliseconds));
+      delay);
   loop->Run();
 }
 
 TEST_F(IPCChannelPosixTest, BasicListen) {
   const std::string kChannelName =
       GetChannelDirName() + "/IPCChannelPosixTest_BasicListen";
 
   // Test creating a socket that is listening.
   IPC::ChannelHandle handle(kChannelName);
   SetUpSocket(&handle, IPC::Channel::MODE_NAMED_SERVER);
@@ skipping 34 matching lines @@
   IPC::ChannelHandle chan_handle(GetConnectionSocketName());
   SetUpSocket(&chan_handle, IPC::Channel::MODE_NAMED_SERVER);
   IPC::Channel channel(chan_handle, IPC::Channel::MODE_NAMED_SERVER, &listener);
   ASSERT_TRUE(channel.Connect());
   ASSERT_TRUE(channel.AcceptsConnections());
   ASSERT_FALSE(channel.HasAcceptedConnection());
 
   base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc",
                                           false);
   ASSERT_TRUE(handle);
-  SpinRunLoop(TestTimeouts::action_max_timeout_ms());
+  SpinRunLoop(TestTimeouts::action_max_timeout());
   ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
   ASSERT_TRUE(channel.HasAcceptedConnection());
   IPC::Message* message = new IPC::Message(0,  // routing_id
                                            kQuitMessage,  // message type
                                            IPC::Message::PRIORITY_NORMAL);
   channel.Send(message);
-  SpinRunLoop(TestTimeouts::action_timeout_ms());
+  SpinRunLoop(TestTimeouts::action_timeout());
   int exit_code = 0;
   EXPECT_TRUE(base::WaitForExitCode(handle, &exit_code));
   EXPECT_EQ(0, exit_code);
   ASSERT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, listener.status());
   ASSERT_FALSE(channel.HasAcceptedConnection());
 }
 
 TEST_F(IPCChannelPosixTest, ResetState) {
   // Test creating a connection to an external process. Close the connection,
   // but continue to listen and make sure another external process can connect
   // to us.
   IPCChannelPosixTestListener listener(false);
   IPC::ChannelHandle chan_handle(GetConnectionSocketName());
   SetUpSocket(&chan_handle, IPC::Channel::MODE_NAMED_SERVER);
   IPC::Channel channel(chan_handle, IPC::Channel::MODE_NAMED_SERVER, &listener);
   ASSERT_TRUE(channel.Connect());
   ASSERT_TRUE(channel.AcceptsConnections());
   ASSERT_FALSE(channel.HasAcceptedConnection());
 
   base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc",
                                           false);
   ASSERT_TRUE(handle);
-  SpinRunLoop(TestTimeouts::action_max_timeout_ms());
+  SpinRunLoop(TestTimeouts::action_max_timeout());
   ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
   ASSERT_TRUE(channel.HasAcceptedConnection());
   channel.ResetToAcceptingConnectionState();
   ASSERT_FALSE(channel.HasAcceptedConnection());
 
   base::ProcessHandle handle2 = SpawnChild("IPCChannelPosixTestConnectionProc",
                                           false);
   ASSERT_TRUE(handle2);
-  SpinRunLoop(TestTimeouts::action_max_timeout_ms());
+  SpinRunLoop(TestTimeouts::action_max_timeout());
   ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
   ASSERT_TRUE(channel.HasAcceptedConnection());
   IPC::Message* message = new IPC::Message(0,  // routing_id
                                            kQuitMessage,  // message type
                                            IPC::Message::PRIORITY_NORMAL);
   channel.Send(message);
-  SpinRunLoop(TestTimeouts::action_timeout_ms());
+  SpinRunLoop(TestTimeouts::action_timeout());
   EXPECT_TRUE(base::KillProcess(handle, 0, false));
   int exit_code = 0;
   EXPECT_TRUE(base::WaitForExitCode(handle2, &exit_code));
   EXPECT_EQ(0, exit_code);
   ASSERT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, listener.status());
   ASSERT_FALSE(channel.HasAcceptedConnection());
 }
 
 TEST_F(IPCChannelPosixTest, BadChannelName) {
   // Test empty name
@@ skipping 22 matching lines @@
   IPC::ChannelHandle chan_handle(GetConnectionSocketName());
   SetUpSocket(&chan_handle, IPC::Channel::MODE_NAMED_SERVER);
   IPC::Channel channel(chan_handle, IPC::Channel::MODE_NAMED_SERVER, &listener);
   ASSERT_TRUE(channel.Connect());
   ASSERT_TRUE(channel.AcceptsConnections());
   ASSERT_FALSE(channel.HasAcceptedConnection());
 
   base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc",
                                           false);
   ASSERT_TRUE(handle);
-  SpinRunLoop(TestTimeouts::action_max_timeout_ms());
+  SpinRunLoop(TestTimeouts::action_max_timeout());
   ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
   ASSERT_TRUE(channel.HasAcceptedConnection());
   base::ProcessHandle handle2 = SpawnChild("IPCChannelPosixFailConnectionProc",
                                            false);
   ASSERT_TRUE(handle2);
-  SpinRunLoop(TestTimeouts::action_max_timeout_ms());
+  SpinRunLoop(TestTimeouts::action_max_timeout());
   int exit_code = 0;
   EXPECT_TRUE(base::WaitForExitCode(handle2, &exit_code));
   EXPECT_EQ(exit_code, 0);
   ASSERT_EQ(IPCChannelPosixTestListener::DENIED, listener.status());
   ASSERT_TRUE(channel.HasAcceptedConnection());
   IPC::Message* message = new IPC::Message(0,  // routing_id
                                            kQuitMessage,  // message type
                                            IPC::Message::PRIORITY_NORMAL);
   channel.Send(message);
-  SpinRunLoop(TestTimeouts::action_timeout_ms());
+  SpinRunLoop(TestTimeouts::action_timeout());
   EXPECT_TRUE(base::WaitForExitCode(handle, &exit_code));
   EXPECT_EQ(exit_code, 0);
   ASSERT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, listener.status());
   ASSERT_FALSE(channel.HasAcceptedConnection());
 }
 
 TEST_F(IPCChannelPosixTest, DoubleServer) {
   // Test setting up two servers with the same name.
   IPCChannelPosixTestListener listener(false);
   IPCChannelPosixTestListener listener2(false);
@@ skipping 28 matching lines @@
 }
 
 // A long running process that connects to us
 MULTIPROCESS_TEST_MAIN(IPCChannelPosixTestConnectionProc) {
   MessageLoopForIO message_loop;
   IPCChannelPosixTestListener listener(true);
   IPC::ChannelHandle handle(IPCChannelPosixTest::GetConnectionSocketName());
   IPCChannelPosixTest::SetUpSocket(&handle, IPC::Channel::MODE_NAMED_CLIENT);
   IPC::Channel channel(handle, IPC::Channel::MODE_NAMED_CLIENT, &listener);
   EXPECT_TRUE(channel.Connect());
-  IPCChannelPosixTest::SpinRunLoop(TestTimeouts::action_max_timeout_ms());
+  IPCChannelPosixTest::SpinRunLoop(TestTimeouts::action_max_timeout());
   EXPECT_EQ(IPCChannelPosixTestListener::MESSAGE_RECEIVED, listener.status());
   return 0;
 }
 
 // Simple external process that shouldn't be able to connect to us.
 MULTIPROCESS_TEST_MAIN(IPCChannelPosixFailConnectionProc) {
   MessageLoopForIO message_loop;
   IPCChannelPosixTestListener listener(false);
   IPC::ChannelHandle handle(IPCChannelPosixTest::GetConnectionSocketName());
   IPCChannelPosixTest::SetUpSocket(&handle, IPC::Channel::MODE_NAMED_CLIENT);
   IPC::Channel channel(handle, IPC::Channel::MODE_NAMED_CLIENT, &listener);
 
   // In this case connect may succeed or fail depending on if the packet
   // actually gets sent at sendmsg. Since we never delay on send, we may not
   // see the error. However even if connect succeeds, eventually we will get an
   // error back since the channel will be closed when we attempt to read from
   // it.
   bool connected = channel.Connect();
   if (connected) {
-    IPCChannelPosixTest::SpinRunLoop(TestTimeouts::action_max_timeout_ms());
+    IPCChannelPosixTest::SpinRunLoop(TestTimeouts::action_max_timeout());
     EXPECT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, listener.status());
   } else {
     EXPECT_EQ(IPCChannelPosixTestListener::DISCONNECTED, listener.status());
   }
   return 0;
 }