POSIX: Get IPCSyncChannel unittests working

chrome/common/ipc_sync_channel.cc

 // Copyright (c) 2006-2008 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 "chrome/common/ipc_sync_channel.h"
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/thread_local.h"
 #include "base/message_loop.h"
 #include "base/waitable_event.h"
 #include "base/waitable_event_watcher.h"
 #include "chrome/common/ipc_logging.h"
 #include "chrome/common/ipc_sync_message.h"
 
-#if !defined(OS_WIN)
-#define INFINITE -1
-#endif
-
 using base::TimeDelta;
 using base::TimeTicks;
 using base::WaitableEvent;
 
 namespace IPC {
 // When we're blocked in a Send(), we need to process incoming synchronous
 // messages right away because it could be blocking our reply (either
 // directly from the same object we're calling, or indirectly through one or
 // more other channels).  That means that in SyncContext's OnMessageReceived,
 // we need to process sync message right away if we're blocked.  However a
@@ skipping 338 matching lines @@
   // stop or keep watching.  So we always watch it, and create the event as
   // manual reset since the object watcher might otherwise reset the event
   // when we're doing a WaitMany.
   dispatch_watcher_.StartWatching(sync_context()->GetDispatchEvent(), this);
 }
 
 SyncChannel::~SyncChannel() {
 }
 
 bool SyncChannel::Send(Message* message) {
-  return SendWithTimeout(message, INFINITE);
+  return SendWithTimeout(message, base::kNoTimeout);
 }
 
 bool SyncChannel::SendWithTimeout(Message* message, int timeout_ms) {
   if (!message->is_sync()) {
     ChannelProxy::Send(message);
     return true;
   }
 
   // *this* might get deleted in WaitForReply.
   scoped_refptr<SyncContext> context(sync_context());
   if (context->shutdown_event()->IsSignaled()) {
     delete message;
     return false;
   }
 
-  DCHECK(sync_messages_with_no_timeout_allowed_ || timeout_ms != INFINITE);
+  DCHECK(sync_messages_with_no_timeout_allowed_ || timeout_ms != base::kNoTimeout);

[jam, 2009/01/17 02:12:37]

80 characters

   SyncMessage* sync_msg = static_cast<SyncMessage*>(message);
   context->Push(sync_msg);
   int message_id = SyncMessage::GetMessageId(*sync_msg);
   WaitableEvent* pump_messages_event = sync_msg->pump_messages_event();
 
   ChannelProxy::Send(message);
 
-  if (timeout_ms != INFINITE) {
+  if (timeout_ms != base::kNoTimeout) {
     // We use the sync message id so that when a message times out, we don't
     // confuse it with another send that is either above/below this Send in
     // the call stack.
     context->ipc_message_loop()->PostDelayedTask(FROM_HERE, 
         NewRunnableMethod(context.get(),
             &SyncContext::OnSendTimeout, message_id), timeout_ms);
   }
 
   // Wait for reply, or for any other incoming synchronous messages.
   WaitForReply(pump_messages_event);
@@ skipping 47 matching lines @@
     dispatch_watcher_.StartWatching(dispatch_event, this);
     sync_context()->DispatchMessages();
   } else {
     // We got the reply, timed out or the process shutdown.
     DCHECK(event == sync_context()->GetSendDoneEvent());
     MessageLoop::current()->Quit();
   }
 }
 
 }  // namespace IPC