Fix P2PSocketHostTcp to handle async write correctly.

content/browser/renderer_host/p2p/socket_host_tcp.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 "content/browser/renderer_host/p2p/socket_host_tcp.h"
 
 #include "base/sys_byteorder.h"
 #include "content/common/p2p_messages.h"
 #include "ipc/ipc_sender.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/socket/tcp_client_socket.h"
 
 namespace {
 const int kReadBufferSize = 4096;
 const int kPacketHeaderSize = sizeof(uint16);
 }  // namespace
 
 namespace content {
 
 P2PSocketHostTcp::P2PSocketHostTcp(IPC::Sender* message_sender, int id)
     : P2PSocketHost(message_sender, id),
+      write_pending_(false),
       connected_(false) {
 }
 
 P2PSocketHostTcp::~P2PSocketHostTcp() {
   if (state_ == STATE_OPEN) {
     DCHECK(socket_.get());
     socket_.reset();
   }
 }
 
@@ skipping 185 matching lines @@
   if (write_buffer_) {
     write_queue_.push(buffer);
     return;
   }
 
   write_buffer_ = buffer;
   DoWrite();
 }
 
 void P2PSocketHostTcp::DoWrite() {
-  while (write_buffer_ && state_ == STATE_OPEN) {
+  while (write_buffer_ && state_ == STATE_OPEN && !write_pending_) {
     int result = socket_->Write(write_buffer_, write_buffer_->BytesRemaining(),
                                 base::Bind(&P2PSocketHostTcp::OnWritten,
                                            base::Unretained(this)));
     HandleWriteResult(result);
   }
 }
 
 void P2PSocketHostTcp::OnWritten(int result) {
+  DCHECK(write_pending_);
   DCHECK_NE(result, net::ERR_IO_PENDING);
+
+  write_pending_ = false;
   HandleWriteResult(result);
   DoWrite();
 }
 
 void P2PSocketHostTcp::HandleWriteResult(int result) {
   DCHECK(write_buffer_);
   if (result >= 0) {
     write_buffer_->DidConsume(result);
     if (write_buffer_->BytesRemaining() == 0) {
       message_sender_->Send(new P2PMsg_OnSendComplete(id_));
       if (write_queue_.empty()) {
         write_buffer_ = NULL;
       } else {
         write_buffer_ = write_queue_.front();
         write_queue_.pop();
       }
     }
-  } else if (result != net::ERR_IO_PENDING) {
+  } else if (result == net::ERR_IO_PENDING) {
+    write_pending_ = true;
+  } else {
     LOG(ERROR) << "Error when sending data in TCP socket: " << result;
     OnError();
   }
 }
 
 P2PSocketHost* P2PSocketHostTcp::AcceptIncomingTcpConnection(
     const net::IPEndPoint& remote_address, int id) {
   NOTREACHED();
   OnError();
   return NULL;
 }
 
 } // namespace content