Wire up rtc_packet_ids to P2PSocketHostTcp, which is required for correct BWE in WebRTC.

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 <stddef.h>
 #include <utility>
 
 #include "base/location.h"
@@ skipping 31 matching lines @@
 
 bool IsPseudoTlsClientSocket(content::P2PSocketType type) {
   return (type == content::P2P_SOCKET_SSLTCP_CLIENT ||
           type == content::P2P_SOCKET_STUN_SSLTCP_CLIENT);
 }
 
 }  // namespace
 
 namespace content {
 
+P2PSocketHostTcp::SendBuffer::SendBuffer() : rtc_packet_id(-1) {}
+P2PSocketHostTcp::SendBuffer::SendBuffer(
+    int32_t rtc_packet_id,
+    scoped_refptr<net::DrainableIOBuffer> buffer)
+    : rtc_packet_id(rtc_packet_id), buffer(buffer) {}
+P2PSocketHostTcp::SendBuffer::SendBuffer(const SendBuffer& rhs)
+    : rtc_packet_id(rhs.rtc_packet_id), buffer(rhs.buffer) {}
+P2PSocketHostTcp::SendBuffer::~SendBuffer() {}
+
 P2PSocketHostTcpBase::P2PSocketHostTcpBase(
     IPC::Sender* message_sender,
     int socket_id,
     P2PSocketType type,
     net::URLRequestContextGetter* url_context)
     : P2PSocketHost(message_sender, socket_id, P2PSocketHost::TCP),
       write_pending_(false),
       connected_(false),
       type_(type),
       url_context_(url_context) {
@@ skipping 314 matching lines @@
       LOG(ERROR) << "Page tried to send a data packet to " << to.ToString()
                  << " before STUN binding is finished.";
       OnError();
       return;
     }
   }
 
   DoSend(to, data, options);
 }
 
-void P2PSocketHostTcpBase::WriteOrQueue(
-    scoped_refptr<net::DrainableIOBuffer>& buffer) {
+void P2PSocketHostTcpBase::WriteOrQueue(SendBuffer& send_buffer) {
   IncrementTotalSentPackets();
-  if (write_buffer_.get()) {
-    write_queue_.push(buffer);
+  if (write_buffer_.buffer.get()) {
+    write_queue_.push(send_buffer);
     IncrementDelayedPackets();
-    IncrementDelayedBytes(buffer->size());
+    IncrementDelayedBytes(send_buffer.buffer->size());
     return;
   }
 
-  write_buffer_ = buffer;
+  write_buffer_ = send_buffer;
   DoWrite();
 }
 
 void P2PSocketHostTcpBase::DoWrite() {
-  while (write_buffer_.get() && state_ == STATE_OPEN && !write_pending_) {
+  while (write_buffer_.buffer.get() && state_ == STATE_OPEN &&
+         !write_pending_) {
     int result = socket_->Write(
-        write_buffer_.get(),
-        write_buffer_->BytesRemaining(),
+        write_buffer_.buffer.get(), write_buffer_.buffer->BytesRemaining(),
         base::Bind(&P2PSocketHostTcp::OnWritten, base::Unretained(this)));
     HandleWriteResult(result);
   }
 }
 
 void P2PSocketHostTcpBase::OnWritten(int result) {
   DCHECK(write_pending_);
   DCHECK_NE(result, net::ERR_IO_PENDING);
 
   write_pending_ = false;
   HandleWriteResult(result);
   DoWrite();
 }
 
 void P2PSocketHostTcpBase::HandleWriteResult(int result) {
-  DCHECK(write_buffer_.get());
+  DCHECK(write_buffer_.buffer.get());
   if (result >= 0) {
-    write_buffer_->DidConsume(result);
-    if (write_buffer_->BytesRemaining() == 0) {
-      message_sender_->Send(
-          new P2PMsg_OnSendComplete(id_, P2PSendPacketMetrics()));
+    write_buffer_.buffer->DidConsume(result);
+    if (write_buffer_.buffer->BytesRemaining() == 0) {
+      base::TimeTicks send_time = base::TimeTicks::Now();
+      message_sender_->Send(new P2PMsg_OnSendComplete(
+          id_,
+          P2PSendPacketMetrics(0, write_buffer_.rtc_packet_id, send_time)));
       if (write_queue_.empty()) {
-        write_buffer_ = nullptr;
+        write_buffer_.buffer = nullptr;
+        write_buffer_.rtc_packet_id = -1;
       } else {
         write_buffer_ = write_queue_.front();
         write_queue_.pop();
         // Update how many bytes are still waiting to be sent.
-        DecrementDelayedBytes(write_buffer_->size());
+        DecrementDelayedBytes(write_buffer_.buffer->size());
       }
     }
   } else if (result == net::ERR_IO_PENDING) {
     write_pending_ = true;
   } else {
     ReportSocketError(result, "WebRTC.ICE.TcpSocketWriteErrorCode");
 
     LOG(ERROR) << "Error when sending data in TCP socket: " << result;
     OnError();
   }
@@ skipping 80 matching lines @@
   std::vector<char> data(cur, cur + packet_size);
   OnPacket(data);
   consumed += packet_size;
   return consumed;
 }
 
 void P2PSocketHostTcp::DoSend(const net::IPEndPoint& to,
                               const std::vector<char>& data,
                               const rtc::PacketOptions& options) {
   int size = kPacketHeaderSize + data.size();
-  scoped_refptr<net::DrainableIOBuffer> buffer =
-      new net::DrainableIOBuffer(new net::IOBuffer(size), size);
-  *reinterpret_cast<uint16_t*>(buffer->data()) = base::HostToNet16(data.size());
-  memcpy(buffer->data() + kPacketHeaderSize, &data[0], data.size());
+  SendBuffer send_buffer(options.packet_id, new net::DrainableIOBuffer(
+                                                new net::IOBuffer(size), size));
+  *reinterpret_cast<uint16_t*>(send_buffer.buffer->data()) =
+      base::HostToNet16(data.size());
+  memcpy(send_buffer.buffer->data() + kPacketHeaderSize, &data[0], data.size());
 
   cricket::ApplyPacketOptions(
-      reinterpret_cast<uint8_t*>(buffer->data()) + kPacketHeaderSize,
-      buffer->BytesRemaining() - kPacketHeaderSize, options.packet_time_params,
+      reinterpret_cast<uint8_t*>(send_buffer.buffer->data()) +
+          kPacketHeaderSize,
+      send_buffer.buffer->BytesRemaining() - kPacketHeaderSize,
+      options.packet_time_params,
       (base::TimeTicks::Now() - base::TimeTicks()).InMicroseconds());
 
-  WriteOrQueue(buffer);
+  WriteOrQueue(send_buffer);
 }
 
 // P2PSocketHostStunTcp
 P2PSocketHostStunTcp::P2PSocketHostStunTcp(
     IPC::Sender* message_sender,
     int socket_id,
     P2PSocketType type,
     net::URLRequestContextGetter* url_context)
     : P2PSocketHostTcpBase(message_sender, socket_id, type, url_context) {
   DCHECK(type == P2P_SOCKET_STUN_TCP_CLIENT ||
@@ skipping 43 matching lines @@
   // Accepts only complete STUN/TURN packets.
   if (data.size() != expected_len) {
     NOTREACHED();
     OnError();
     return;
   }
 
   // Add any pad bytes to the total size.
   int size = data.size() + pad_bytes;
 
-  scoped_refptr<net::DrainableIOBuffer> buffer =
-      new net::DrainableIOBuffer(new net::IOBuffer(size), size);
-  memcpy(buffer->data(), &data[0], data.size());
+  SendBuffer send_buffer(options.packet_id, new net::DrainableIOBuffer(
+                                                new net::IOBuffer(size), size));
+  memcpy(send_buffer.buffer->data(), &data[0], data.size());
 
   cricket::ApplyPacketOptions(
-      reinterpret_cast<uint8_t*>(buffer->data()), data.size(),
+      reinterpret_cast<uint8_t*>(send_buffer.buffer->data()), data.size(),
       options.packet_time_params,
       (base::TimeTicks::Now() - base::TimeTicks()).InMicroseconds());
 
   if (pad_bytes) {
     char padding[4] = {0};
     DCHECK_LE(pad_bytes, 4);
-    memcpy(buffer->data() + data.size(), padding, pad_bytes);
+    memcpy(send_buffer.buffer->data() + data.size(), padding, pad_bytes);
   }
-  WriteOrQueue(buffer);
+  WriteOrQueue(send_buffer);
 
   if (dump_outgoing_rtp_packet_)
-    DumpRtpPacket(buffer->data(), data.size(), false);
+    DumpRtpPacket(send_buffer.buffer->data(), data.size(), false);
 }
 
 int P2PSocketHostStunTcp::GetExpectedPacketSize(
     const char* data, int len, int* pad_bytes) {
   DCHECK_LE(kTurnChannelDataHeaderSize, len);
   // Both stun and turn had length at offset 2.
   int packet_size = base::NetToHost16(
       *reinterpret_cast<const uint16_t*>(data + kPacketLengthOffset));
 
   // Get packet type (STUN or TURN).
   uint16_t msg_type =
       base::NetToHost16(*reinterpret_cast<const uint16_t*>(data));
 
   *pad_bytes = 0;
   // Add heder length to packet length.
   if ((msg_type & 0xC000) == 0) {
     packet_size += kStunHeaderSize;
   } else {
     packet_size += kTurnChannelDataHeaderSize;
     // Calculate any padding if present.
     if (packet_size % 4)
       *pad_bytes = 4 - packet_size % 4;
   }
   return packet_size;
 }
 
 }  // namespace content