Send notification about outgoing p2p packets from browser to renderer.

content/browser/renderer_host/p2p/socket_host_udp.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_udp.h"
 
 #include "base/bind.h"
 #include "content/common/p2p_messages.h"
 #include "ipc/ipc_sender.h"
 #include "net/base/io_buffer.h"
@@ skipping 24 matching lines @@
       size(content.size()) {
   memcpy(data->data(), &content[0], size);
 }
 
 P2PSocketHostUdp::PendingPacket::~PendingPacket() {
 }
 
 P2PSocketHostUdp::P2PSocketHostUdp(IPC::Sender* message_sender, int id)
     : P2PSocketHost(message_sender, id),
       socket_(new net::UDPServerSocket(NULL, net::NetLog::Source())),
-      send_queue_bytes_(0),
       send_pending_(false) {
 }
 
 P2PSocketHostUdp::~P2PSocketHostUdp() {
   if (state_ == STATE_OPEN) {
     DCHECK(socket_.get());
     socket_.reset();
   }
 }
 
@@ skipping 39 matching lines @@
 }
 
 void P2PSocketHostUdp::DoRead() {
   int result;
   do {
     result = socket_->RecvFrom(recv_buffer_, kReadBufferSize, &recv_address_,
                                base::Bind(&P2PSocketHostUdp::OnRecv,
                                           base::Unretained(this)));
     if (result == net::ERR_IO_PENDING)
       return;
-    DidCompleteRead(result);
+    HandleReadResult(result);
   } while (state_ == STATE_OPEN);
 }
 
 void P2PSocketHostUdp::OnRecv(int result) {
-  DidCompleteRead(result);
+  HandleReadResult(result);
   if (state_ == STATE_OPEN) {
     DoRead();
   }
 }
 
-void P2PSocketHostUdp::DidCompleteRead(int result) {
+void P2PSocketHostUdp::HandleReadResult(int result) {
   DCHECK_EQ(state_, STATE_OPEN);
 
   if (result > 0) {
     std::vector<char> data(recv_buffer_->data(), recv_buffer_->data() + result);
 
     if (connected_peers_.find(recv_address_) == connected_peers_.end()) {
       P2PSocketHost::StunMessageType type;
       bool stun = GetStunPacketType(&*data.begin(), data.size(), &type);
       if (stun && IsRequestOrResponse(type)) {
         connected_peers_.insert(recv_address_);
@@ skipping 25 matching lines @@
     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;
     }
   }
 
   if (send_pending_) {
-    if (send_queue_bytes_ + static_cast<int>(data.size()) >
-        kMaxSendBufferSize) {
-      LOG(WARNING) << "Send buffer is full. Dropping a packet.";
-      return;
-    }
     send_queue_.push_back(PendingPacket(to, data));
-    send_queue_bytes_ += data.size();
   } else {
     PendingPacket packet(to, data);
     DoSend(packet);
   }
 }
 
 void P2PSocketHostUdp::DoSend(const PendingPacket& packet) {
   int result = socket_->SendTo(packet.data, packet.size, packet.to,
                                base::Bind(&P2PSocketHostUdp::OnSend,
                                           base::Unretained(this)));
 
   // sendto() may return an error, e.g. if we've received an ICMP Destination
   // Unreachable message. When this happens try sending the same packet again,
   // and just drop it if it fails again.
   if (IsTransientError(result)) {
     result = socket_->SendTo(packet.data, packet.size, packet.to,
                              base::Bind(&P2PSocketHostUdp::OnSend,
                                         base::Unretained(this)));
   }
 
   if (result == net::ERR_IO_PENDING) {
     send_pending_ = true;
-  } else if (IsTransientError(result)) {
-    LOG(INFO) << "sendto() has failed twice returning a "
-        " transient error. Dropping the packet.";
-  } else if (result < 0) {
-    LOG(ERROR) << "Error when sending data in UDP socket: " << result;
-    OnError();
+  } else {
+    HandleSendResult(result);
   }
 }
 
 void P2PSocketHostUdp::OnSend(int result) {
   DCHECK(send_pending_);
   DCHECK_NE(result, net::ERR_IO_PENDING);
 
   send_pending_ = false;
 
-  if (result < 0 && !IsTransientError(result)) {
-    OnError();
-    return;
-  }
+  HandleSendResult(result);
 
   // Send next packets if we have them waiting in the buffer.
-  while (!send_queue_.empty() && !send_pending_) {
+  while (state_ == STATE_OPEN && !send_queue_.empty() && !send_pending_) {
     DoSend(send_queue_.front());
-    send_queue_bytes_ -= send_queue_.front().size;
     send_queue_.pop_front();
   }
 }
 
+void P2PSocketHostUdp::HandleSendResult(int result) {
+  if (result > 0) {
+    message_sender_->Send(new P2PMsg_OnSendComplete(id_));
+  } else if (IsTransientError(result)) {
+    LOG(INFO) << "sendto() has failed twice returning a "
+        " transient error. Dropping the packet.";
+  } else if (result < 0) {
+    LOG(ERROR) << "Error when sending data in UDP socket: " << result;
+    OnError();
+  }
+}
+
 P2PSocketHost* P2PSocketHostUdp::AcceptIncomingTcpConnection(
     const net::IPEndPoint& remote_address, int id) {
   NOTREACHED();
   OnError();
   return NULL;
 }
 
 }  // namespace content