Add a Mojo EDK for Chrome that uses one OS pipe per message pipe.

net/socket/tcp_socket_win.cc

 // Copyright 2013 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 "net/socket/tcp_socket.h"
 #include "net/socket/tcp_socket_win.h"
 
 #include <mstcpip.h>
 
 #include "base/callback_helpers.h"
@@ skipping 217 matching lines @@
   WSACloseEvent(read_overlapped_.hEvent);
   memset(&read_overlapped_, 0xaf, sizeof(read_overlapped_));
   WSACloseEvent(write_overlapped_.hEvent);
   memset(&write_overlapped_, 0xaf, sizeof(write_overlapped_));
 }
 
 void TCPSocketWin::Core::WatchForRead() {
   // We grab an extra reference because there is an IO operation in progress.
   // Balanced in ReadDelegate::OnObjectSignaled().
   AddRef();
-  read_watcher_.StartWatching(read_overlapped_.hEvent, &reader_);
+  read_watcher_.StartWatching(read_overlapped_.hEvent, &reader_, false);
 }
 
 void TCPSocketWin::Core::WatchForWrite() {
   // We grab an extra reference because there is an IO operation in progress.
   // Balanced in WriteDelegate::OnObjectSignaled().
   AddRef();
-  write_watcher_.StartWatching(write_overlapped_.hEvent, &writer_);
+  write_watcher_.StartWatching(write_overlapped_.hEvent, &writer_, false);
 }
 
 void TCPSocketWin::Core::ReadDelegate::OnObjectSignaled(HANDLE object) {
   DCHECK_EQ(object, core_->read_overlapped_.hEvent);
   if (core_->socket_) {
     if (core_->socket_->waiting_connect_)
       core_->socket_->DidCompleteConnect();
     else
       core_->socket_->DidSignalRead();
   }
@@ skipping 139 matching lines @@
   DCHECK(!callback.is_null());
   DCHECK(accept_callback_.is_null());
 
   net_log_.BeginEvent(NetLog::TYPE_TCP_ACCEPT);
 
   int result = AcceptInternal(socket, address);
 
   if (result == ERR_IO_PENDING) {
     // Start watching.
     WSAEventSelect(socket_, accept_event_, FD_ACCEPT);
-    accept_watcher_.StartWatching(accept_event_, this);
+    accept_watcher_.StartWatching(accept_event_, this, false);
 
     accept_socket_ = socket;
     accept_address_ = address;
     accept_callback_ = callback;
   }
 
   return result;
 }
 
 int TCPSocketWin::Connect(const IPEndPoint& address,
@@ skipping 349 matching lines @@
       accept_address_ = NULL;
       base::ResetAndReturn(&accept_callback_).Run(result);
     }
   } else {
     // This happens when a client opens a connection and closes it before we
     // have a chance to accept it.
     DCHECK(ev.lNetworkEvents == 0);
 
     // Start watching the next FD_ACCEPT event.
     WSAEventSelect(socket_, accept_event_, FD_ACCEPT);
-    accept_watcher_.StartWatching(accept_event_, this);
+    accept_watcher_.StartWatching(accept_event_, this, false);
   }
 }
 
 int TCPSocketWin::DoConnect() {
   DCHECK_EQ(connect_os_error_, 0);
   DCHECK(!core_.get());
 
   net_log_.BeginEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT,
                       CreateNetLogIPEndPointCallback(peer_address_.get()));
 
@@ skipping 258 matching lines @@
 }
 
 bool TCPSocketWin::GetEstimatedRoundTripTime(base::TimeDelta* out_rtt) const {
   DCHECK(out_rtt);
   // TODO(bmcquade): Consider implementing using
   // GetPerTcpConnectionEStats/GetPerTcp6ConnectionEStats.
   return false;
 }
 
 }  // namespace net