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

ipc/ipc_fuzzing_tests.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.
 
 #include <stdio.h>
 #include <string>
 #include <sstream>
 
 #include "base/message_loop.h"
 #include "base/process_util.h"
@@ skipping 264 matching lines @@
   IPC::Message* msg = NULL;
   int value = 43;
   msg = new MsgClassIS(value, L"expect 43");
   chan.Send(msg);
   EXPECT_TRUE(listener.ExpectMessage(value, MsgClassIS::ID));
 
   msg = new MsgClassSI(L"expect 44", ++value);
   chan.Send(msg);
   EXPECT_TRUE(listener.ExpectMessage(value, MsgClassSI::ID));
 
-  EXPECT_TRUE(base::WaitForSingleProcess(server_process, 5000));
+  EXPECT_TRUE(base::WaitForSingleProcess(
+      server_process, base::TimeDelta::FromSeconds(5)));
   base::CloseProcessHandle(server_process);
 }
 
 // This test uses a payload that is smaller than expected.
 // This generates an error while unpacking the IPC buffer which in
 // In debug this triggers an assertion and in release it is ignored(!!). Right
 // after we generate another valid IPC to make sure framing is working
 // properly.
 #if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
 TEST_F(IPCFuzzingTest, MsgBadPayloadShort) {
   FuzzerClientListener listener;
   IPC::Channel chan(kFuzzerChannel, IPC::Channel::MODE_SERVER,
                     &listener);
   base::ProcessHandle server_process = SpawnChild(FUZZER_SERVER, &chan);
   ASSERT_TRUE(server_process);
   base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
   ASSERT_TRUE(chan.Connect());
   listener.Init(&chan);
 
   IPC::Message* msg = new IPC::Message(MSG_ROUTING_CONTROL, MsgClassIS::ID,
                                        IPC::Message::PRIORITY_NORMAL);
   msg->WriteInt(666);
   chan.Send(msg);
   EXPECT_TRUE(listener.ExpectMsgNotHandled(MsgClassIS::ID));
 
   msg = new MsgClassSI(L"expect one", 1);
   chan.Send(msg);
   EXPECT_TRUE(listener.ExpectMessage(1, MsgClassSI::ID));
 
-  EXPECT_TRUE(base::WaitForSingleProcess(server_process, 5000));
+  EXPECT_TRUE(base::WaitForSingleProcess(
+      server_process, base::TimeDelta::FromSeconds(5)));
   base::CloseProcessHandle(server_process);
 }
 #endif
 
 // This test uses a payload that has too many arguments, but so the payload
 // size is big enough so the unpacking routine does not generate an error as
 // in the case of MsgBadPayloadShort test.
 // This test does not pinpoint a flaw (per se) as by design we don't carry
 // type information on the IPC message.
 TEST_F(IPCFuzzingTest, MsgBadPayloadArgs) {
@@ skipping 14 matching lines @@
 
   chan.Send(msg);
   EXPECT_TRUE(listener.ExpectMessage(0, MsgClassSI::ID));
 
   // Now send a well formed message to make sure the receiver wasn't
   // thrown out of sync by the extra argument.
   msg = new MsgClassIS(3, L"expect three");
   chan.Send(msg);
   EXPECT_TRUE(listener.ExpectMessage(3, MsgClassIS::ID));
 
-  EXPECT_TRUE(base::WaitForSingleProcess(server_process, 5000));
+  EXPECT_TRUE(base::WaitForSingleProcess(
+      server_process, base::TimeDelta::FromSeconds(5)));
   base::CloseProcessHandle(server_process);
 }
 
 // This class is for testing the IPC_BEGIN_MESSAGE_MAP_EX macros.
 class ServerMacroExTest {
  public:
   ServerMacroExTest() : unhandled_msgs_(0) {
   }
 
   virtual ~ServerMacroExTest() {
@@ skipping 47 matching lines @@
   msg = new IPC::Message(MSG_ROUTING_CONTROL, MsgClassIS::ID,
                          IPC::Message::PRIORITY_NORMAL);
   msg->WriteInt(0x64);
   msg->WriteInt(0x32);
   EXPECT_FALSE(server.OnMessageReceived(*msg));
   delete msg;
 
   EXPECT_EQ(0, server.unhandled_msgs());
 #endif
 }