Update webrtc&libjingle 6774:6825.

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"
+#include "third_party/webrtc/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 291 matching lines @@
       id_, remote_address_.ip_address, data, base::TimeTicks::Now()));
 
   if (dump_incoming_rtp_packet_)
     DumpRtpPacket(&data[0], data.size(), true);
 }
 
 // Note: dscp is not actually used on TCP sockets as this point,
 // but may be honored in the future.
 void P2PSocketHostTcpBase::Send(const net::IPEndPoint& to,
                                 const std::vector<char>& data,
-                                const talk_base::PacketOptions& options,
+                                const rtc::PacketOptions& options,
                                 uint64 packet_id) {
   if (!socket_) {
     // The Send message may be sent after the an OnError message was
     // sent by hasn't been processed the renderer.
     return;
   }
 
   if (!(to == remote_address_.ip_address)) {
     // Renderer should use this socket only to send data to |remote_address_|.
     NOTREACHED();
@@ skipping 139 matching lines @@
   int consumed = kPacketHeaderSize;
   char* cur = input + consumed;
   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 talk_base::PacketOptions& options) {
+                              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*>(buffer->data()) = base::HostToNet16(data.size());
   memcpy(buffer->data() + kPacketHeaderSize, &data[0], data.size());
 
   packet_processing_helpers::ApplyPacketOptions(
       buffer->data() + kPacketHeaderSize,
       buffer->BytesRemaining() - kPacketHeaderSize,
       options, 0);
@@ skipping 32 matching lines @@
   char* cur = input;
   std::vector<char> data(cur, cur + packet_size);
   OnPacket(data);
   consumed += packet_size;
   consumed += pad_bytes;
   return consumed;
 }
 
 void P2PSocketHostStunTcp::DoSend(const net::IPEndPoint& to,
                                   const std::vector<char>& data,
-                                  const talk_base::PacketOptions& options) {
+                                  const rtc::PacketOptions& options) {
   // Each packet is expected to have header (STUN/TURN ChannelData), where
   // header contains message type and and length of message.
   if (data.size() < kPacketHeaderSize + kPacketLengthOffset) {
     NOTREACHED();
     OnError();
     return;
   }
 
   int pad_bytes;
   size_t expected_len = GetExpectedPacketSize(
@@ skipping 44 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