Send notification about outgoing p2p packets from browser to renderer.

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"
@@ skipping 69 matching lines @@
 
 void P2PSocketHostTcp::OnConnected(int result) {
   DCHECK_EQ(state_, STATE_CONNECTING);
   DCHECK_NE(result, net::ERR_IO_PENDING);
 
   if (result != net::OK) {
     OnError();
     return;
   }
 
-  if (!socket_->SetSendBufferSize(kMaxSendBufferSize)) {
-    LOG(WARNING) << "Failed to set send buffer size for TCP socket.";
-  }
-
   net::IPEndPoint address;
   result = socket_->GetLocalAddress(&address);
   if (result < 0) {
     LOG(ERROR) << "P2PSocket::Init(): unable to get local address: "
                << result;
     OnError();
     return;
   }
 
   VLOG(1) << "Local address: " << address.ToString();
@@ skipping 85 matching lines @@
 }
 
 void P2PSocketHostTcp::Send(const net::IPEndPoint& to,
                             const std::vector<char>& data) {
   if (!socket_.get()) {
     // The Send message may be sent after the an OnError message was
     // sent by hasn't been processed the renderer.
     return;
   }
 
-  if (write_buffer_) {
-    // Silently drop packet if we haven't finished sending previous
-    // packet.
-    VLOG(1) << "Dropping TCP packet.";
-    return;
-  }
-
   if (!(to == remote_address_)) {
-    // Renderer should use this socket only to send data to
-    // |remote_address_|.
+    // Renderer should use this socket only to send data to |remote_address_|.
     NOTREACHED();
     OnError();
     return;
   }
 
   if (!connected_) {
     P2PSocketHost::StunMessageType type;
     bool stun = GetStunPacketType(&*data.begin(), data.size(), &type);
     if (!stun || type == STUN_DATA_INDICATION) {
       LOG(ERROR) << "Page tried to send a data packet to " << to.ToString()
                  << " before STUN binding is finished.";
       OnError();
       return;
     }
   }
 
   int size = kPacketHeaderSize + data.size();
-  write_buffer_ = new net::DrainableIOBuffer(new net::IOBuffer(size), size);
-  *reinterpret_cast<uint16*>(write_buffer_->data()) =
-      base::HostToNet16(data.size());
-  memcpy(write_buffer_->data() + kPacketHeaderSize, &data[0], data.size());
+  scoped_refptr<net::DrainableIOBuffer> buffer =
+      new net::DrainableIOBuffer(new net::IOBuffer(size), size);
+  *reinterpret_cast<uint16*>(buffer->data()) = base::HostToNet16(data.size());
+  memcpy(buffer->data() + kPacketHeaderSize, &data[0], data.size());
 
+  if (write_buffer_) {
+    write_queue_.push(buffer);
+    return;
+  }
+
+  write_buffer_ = buffer;
   DoWrite();
 }
 
 void P2PSocketHostTcp::DoWrite() {
-  while (true) {
+  while (write_buffer_ && state_ == STATE_OPEN) {
     int result = socket_->Write(write_buffer_, write_buffer_->BytesRemaining(),
                                 base::Bind(&P2PSocketHostTcp::OnWritten,
                                            base::Unretained(this)));
-    if (result >= 0) {
-      write_buffer_->DidConsume(result);
-      if (write_buffer_->BytesRemaining() == 0) {
-        write_buffer_ = NULL;
-        break;
-      }
-    } else {
-      if (result != net::ERR_IO_PENDING) {
-        LOG(ERROR) << "Error when sending data in TCP socket: " << result;
-        OnError();
-      }
-      break;
-    }
+    HandleWriteResult(result);
   }
 }
 
 void P2PSocketHostTcp::OnWritten(int result) {
   DCHECK(write_buffer_);
   DCHECK_NE(result, net::ERR_IO_PENDING);
 
   if (result < 0) {

[Ronghua Wu (Left Chromium), 2013/04/04 05:23:59]

you can remove this part now.

[Sergey Ulanov, 2013/04/04 18:40:34]

Done.

     DCHECK(result != net::ERR_IO_PENDING);
     LOG(ERROR) << "Error when sending data in TCP socket: " << result;
     OnError();
     return;
   }
 
-  write_buffer_->DidConsume(result);
-  if (write_buffer_->BytesRemaining() == 0) {
-    write_buffer_ = NULL;
-  } else {
-    DoWrite();
+  HandleWriteResult(result);
+  DoWrite();
+}
+
+void P2PSocketHostTcp::HandleWriteResult(int result) {
+  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) {
+    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