This CL adds methods to manipulate RTP header extension, particularly

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 "jingle/glue/fake_ssl_client_socket.h"
 #include "jingle/glue/proxy_resolving_client_socket.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/tcp_client_socket.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
+#include "third_party/libjingle/source/talk/base/asyncpacketsocket.h"
 
 namespace {
 
 typedef uint16 PacketLength;
 const int kPacketHeaderSize = sizeof(PacketLength);
 const int kReadBufferSize = 4096;
 const int kPacketLengthOffset = 2;
 const int kTurnChannelDataHeaderSize = 4;
 const int kRecvSocketBufferSize = 128 * 1024;
 const int kSendSocketBufferSize = 128 * 1024;
@@ skipping 416 matching lines @@
 }
 
 void P2PSocketHostTcp::DoSend(const net::IPEndPoint& to,
                               const std::vector<char>& data) {
   int size = kPacketHeaderSize + 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());
 
+  talk_base::PacketOptions options;

[Solis, 2014/02/26 15:49:34]

So I guess initializing 'options' to something other than default will come in a
later CL?

[Mallinath (Gone from Chromium), 2014/02/26 19:59:20]

Yes.
On 2014/02/26 15:49:34, Solis wrote:

+  MaybeUpdatePacketSendTimeExtn(buffer->data(), buffer->BytesRemaining(),
+                                options);
+
   WriteOrQueue(buffer);
 }
 
 // P2PSocketHostStunTcp
 P2PSocketHostStunTcp::P2PSocketHostStunTcp(
     IPC::Sender* message_sender, int id,
     P2PSocketType type, net::URLRequestContextGetter* url_context)
     : P2PSocketHostTcpBase(message_sender, id, type, url_context) {
   DCHECK(type == P2P_SOCKET_STUN_TCP_CLIENT ||
          type == P2P_SOCKET_STUN_SSLTCP_CLIENT ||
@@ skipping 45 matching lines @@
     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());
 
+  // Update HMAC before writing padding bytes at the end.
+  talk_base::PacketOptions options;
+  MaybeUpdatePacketSendTimeExtn(buffer->data(), data.size(), options);
+
   if (pad_bytes) {
     char padding[4] = {0};
     DCHECK_LE(pad_bytes, 4);
     memcpy(buffer->data() + data.size(), padding, pad_bytes);
   }
   WriteOrQueue(buffer);
 }
 
 int P2PSocketHostStunTcp::GetExpectedPacketSize(
     const char* data, int len, int* pad_bytes) {
@@ skipping 12 matching lines @@
   } else {
     packet_size += kTurnChannelDataHeaderSize;
     // Calculate any padding if present.
     if (packet_size % 4)
       *pad_bytes = 4 - packet_size % 4;
   }
   return packet_size;
 }
 
 }  // namespace content