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

content/browser/renderer_host/p2p/socket_host_tcp.cc

Index: content/browser/renderer_host/p2p/socket_host_tcp.cc
diff --git a/content/browser/renderer_host/p2p/socket_host_tcp.cc b/content/browser/renderer_host/p2p/socket_host_tcp.cc
index 039c619ccf45ebe68b58ffca31c0c5a50b419fd7..dc044d307cd3b3566141fda9fefb203f480518ea 100644
--- a/content/browser/renderer_host/p2p/socket_host_tcp.cc
+++ b/content/browser/renderer_host/p2p/socket_host_tcp.cc
@@ -383,13 +383,12 @@ void P2PSocketHostTcpBase::Send(const net::IPEndPoint& to,
   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;
   }
 
@@ -398,10 +397,10 @@ void P2PSocketHostTcpBase::WriteOrQueue(
 }
 
 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);
   }
@@ -417,19 +416,21 @@ void P2PSocketHostTcpBase::OnWritten(int result) {
 }
 
 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) {
@@ -530,14 +531,17 @@ 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);
@@ -604,24 +608,25 @@ void P2PSocketHostStunTcp::DoSend(const net::IPEndPoint& to,
   // 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(