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 365 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& buffer) {
   IncrementTotalSentPackets();
-  if (write_buffer_.get()) {
+  if (write_buffer_.second.get()) {
     write_queue_.push(buffer);
     IncrementDelayedPackets();
-    IncrementDelayedBytes(buffer->size());
+    IncrementDelayedBytes(buffer.second->size());
     return;
   }
 
   write_buffer_ = buffer;
   DoWrite();
 }
 
 void P2PSocketHostTcpBase::DoWrite() {
-  while (write_buffer_.get() && state_ == STATE_OPEN && !write_pending_) {
+  while (write_buffer_.second.get() && state_ == STATE_OPEN &&
+         !write_pending_) {
     int result = socket_->Write(
-        write_buffer_.get(),
-        write_buffer_->BytesRemaining(),
+        write_buffer_.second.get(), write_buffer_.second->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_.second.get());
   if (result >= 0) {
-    write_buffer_->DidConsume(result);
-    if (write_buffer_->BytesRemaining() == 0) {
-      message_sender_->Send(
-          new P2PMsg_OnSendComplete(id_, P2PSendPacketMetrics()));
+    write_buffer_.second->DidConsume(result);
+    if (write_buffer_.second->BytesRemaining() == 0) {
+      base::TimeTicks send_time = base::TimeTicks::Now();
+      message_sender_->Send(new P2PMsg_OnSendComplete(
+          id_, P2PSendPacketMetrics(0, write_buffer_.first, send_time)));
       if (write_queue_.empty()) {
-        write_buffer_ = nullptr;
+        write_buffer_.second = nullptr;
+        write_buffer_.first = -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_.second->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 buffer =
+      std::make_pair(options.packet_id,
+                     new net::DrainableIOBuffer(new net::IOBuffer(size), size));
+  *reinterpret_cast<uint16_t*>(buffer.second->data()) =
+      base::HostToNet16(data.size());
+  memcpy(buffer.second->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*>(buffer.second->data()) + kPacketHeaderSize,
+      buffer.second->BytesRemaining() - kPacketHeaderSize,
+      options.packet_time_params,
       (base::TimeTicks::Now() - base::TimeTicks()).InMicroseconds());
 
   WriteOrQueue(buffer);
 }
 
 // P2PSocketHostStunTcp
 P2PSocketHostStunTcp::P2PSocketHostStunTcp(
     IPC::Sender* message_sender,
     int socket_id,
     P2PSocketType type,
@@ skipping 46 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 buffer =
+      std::make_pair(options.packet_id,
+                     new net::DrainableIOBuffer(new net::IOBuffer(size), size));
+  memcpy(buffer.second->data(), &data[0], data.size());
 
   cricket::ApplyPacketOptions(
-      reinterpret_cast<uint8_t*>(buffer->data()), data.size(),
+      reinterpret_cast<uint8_t*>(buffer.second->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(buffer.second->data() + data.size(), padding, pad_bytes);
   }
   WriteOrQueue(buffer);
 
   if (dump_outgoing_rtp_packet_)
-    DumpRtpPacket(buffer->data(), data.size(), false);
+    DumpRtpPacket(buffer.second->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