Webrtc deps roll.

content/browser/renderer_host/p2p/socket_host.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.h"
 
 #include "base/sys_byteorder.h"
 #include "content/browser/renderer_host/p2p/socket_host_tcp.h"
 #include "content/browser/renderer_host/p2p/socket_host_tcp_server.h"
 #include "content/browser/renderer_host/p2p/socket_host_udp.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "crypto/hmac.h"
-#include "third_party/libjingle/source/talk/base/asyncpacketsocket.h"
-#include "third_party/libjingle/source/talk/base/byteorder.h"
-#include "third_party/libjingle/source/talk/base/messagedigest.h"
 #include "third_party/libjingle/source/talk/p2p/base/stun.h"
+#include "third_party/webrtc/base/asyncpacketsocket.h"
+#include "third_party/webrtc/base/byteorder.h"
+#include "third_party/webrtc/base/messagedigest.h"
 
 namespace {
 
 const uint32 kStunMagicCookie = 0x2112A442;
 const int kMinRtpHdrLen = 12;
 const int kRtpExtnHdrLen = 4;
 const int kDtlsRecordHeaderLen = 13;
 const int kTurnChannelHdrLen = 4;
 const int kAbsSendTimeExtnLen = 3;
 const int kOneByteHdrLen = 1;
@@ skipping 13 matching lines @@
   const uint8* u = reinterpret_cast<const uint8*>(data);
   return (len >= kDtlsRecordHeaderLen && (u[0] > 19 && u[0] < 64));
 }
 
 bool IsRtcpPacket(const char* data) {
   int type = (static_cast<uint8>(data[1]) & 0x7F);
   return (type >= 64 && type < 96);
 }
 
 bool IsTurnSendIndicationPacket(const char* data) {
-  uint16 type = talk_base::GetBE16(data);
+  uint16 type = rtc::GetBE16(data);
   return (type == cricket::TURN_SEND_INDICATION);
 }
 
 bool IsRtpPacket(const char* data, int len) {
   return ((*data & 0xC0) == 0x80);
 }
 
 // Verifies rtp header and message length.
 bool ValidateRtpHeader(const char* rtp, int length, size_t* header_length) {
   if (header_length)
@@ skipping 11 matching lines @@
     if (header_length)
       *header_length = rtp_hdr_len_without_extn;
 
     return true;
   }
 
   rtp += rtp_hdr_len_without_extn;
 
   // Getting extension profile length.
   // Length is in 32 bit words.
-  uint16 extn_length = talk_base::GetBE16(rtp + 2) * 4;
+  uint16 extn_length = rtc::GetBE16(rtp + 2) * 4;
 
   // Verify input length against total header size.
   if (rtp_hdr_len_without_extn + kRtpExtnHdrLen + extn_length > length) {
     return false;
   }
 
   if (header_length)
     *header_length = rtp_hdr_len_without_extn + kRtpExtnHdrLen + extn_length;
   return true;
 }
@@ skipping 28 matching lines @@
   }
   // TODO(mallinath) - Add SetBE24 to byteorder.h in libjingle.
   extn_data[0] = static_cast<uint8>(now_second >> 16);
   extn_data[1] = static_cast<uint8>(now_second >> 8);
   extn_data[2] = static_cast<uint8>(now_second);
 }
 
 // Assumes |len| is actual packet length + tag length. Updates HMAC at end of
 // the RTP packet.
 void UpdateRtpAuthTag(char* rtp, int len,
-                      const talk_base::PacketOptions& options) {
+                      const rtc::PacketOptions& options) {
   // If there is no key, return.
   if (options.packet_time_params.srtp_auth_key.empty())
     return;
 
   size_t tag_length = options.packet_time_params.srtp_auth_tag_len;
   char* auth_tag = rtp + (len - tag_length);
 
   // We should have a fake HMAC value @ auth_tag.
   DCHECK_EQ(0, memcmp(auth_tag, kFakeAuthTag, tag_length));
 
@@ skipping 26 matching lines @@
   memcpy(auth_tag, output, tag_length);
 }
 
 }  // namespace
 
 namespace content {
 
 namespace packet_processing_helpers {
 
 bool ApplyPacketOptions(char* data, int length,
-                        const talk_base::PacketOptions& options,
+                        const rtc::PacketOptions& options,
                         uint32 abs_send_time) {
   DCHECK(data != NULL);
   DCHECK(length > 0);
   // if there is no valid |rtp_sendtime_extension_id| and |srtp_auth_key| in
   // PacketOptions, nothing to be updated in this packet.
   if (options.packet_time_params.rtp_sendtime_extension_id == -1 &&
       options.packet_time_params.srtp_auth_key.empty()) {
     return true;
   }
 
@@ skipping 42 matching lines @@
     // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     // |                                                               |
     // /                       Application Data                        /
     // /                                                               /
     // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     if (length < kTurnChannelHdrLen) {
       return false;
     }
 
     rtp_begin = kTurnChannelHdrLen;
-    rtp_length = talk_base::GetBE16(&packet[2]);
+    rtp_length = rtc::GetBE16(&packet[2]);
     if (length < rtp_length + kTurnChannelHdrLen) {
       return false;
     }
   } else if (IsTurnSendIndicationPacket(packet)) {
     if (length <= P2PSocketHost::kStunHeaderSize) {
       // Message must be greater than 20 bytes, if it's carrying any payload.
       return false;
     }
     // Validate STUN message length.
-    int stun_msg_len = talk_base::GetBE16(&packet[2]);
+    int stun_msg_len = rtc::GetBE16(&packet[2]);
     if (stun_msg_len + P2PSocketHost::kStunHeaderSize != length) {
       return false;
     }
 
     // First skip mandatory stun header which is of 20 bytes.
     rtp_begin = P2PSocketHost::kStunHeaderSize;
     // Loop through STUN attributes until we find STUN DATA attribute.
     const char* start = packet + rtp_begin;
     bool data_attr_present = false;
     while ((packet + rtp_begin) - start < stun_msg_len) {
       // Keep reading STUN attributes until we hit DATA attribute.
       // Attribute will be a TLV structure.
       // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       // |         Type                  |            Length             |
       // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       // |                         Value (variable)                ....
       // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       // The value in the length field MUST contain the length of the Value
       // part of the attribute, prior to padding, measured in bytes.  Since
       // STUN aligns attributes on 32-bit boundaries, attributes whose content
       // is not a multiple of 4 bytes are padded with 1, 2, or 3 bytes of
       // padding so that its value contains a multiple of 4 bytes.  The
       // padding bits are ignored, and may be any value.
       uint16 attr_type, attr_length;
       // Getting attribute type and length.
-      attr_type = talk_base::GetBE16(&packet[rtp_begin]);
-      attr_length = talk_base::GetBE16(
+      attr_type = rtc::GetBE16(&packet[rtp_begin]);
+      attr_length = rtc::GetBE16(
           &packet[rtp_begin + sizeof(attr_type)]);
       // Checking for bogus attribute length.
       if (length < attr_length + rtp_begin) {
         return false;
       }
 
       if (attr_type != cricket::STUN_ATTR_DATA) {
         rtp_begin += sizeof(attr_type) + sizeof(attr_length) + attr_length;
         if ((attr_length % 4) != 0) {
           rtp_begin += (4 - (attr_length % 4));
@@ skipping 56 matching lines @@
   if (!(rtp[0] & 0x10)) {
     return true;
   }
 
   int cc_count = rtp[0] & 0x0F;
   int rtp_hdr_len_without_extn = kMinRtpHdrLen + 4 * cc_count;
 
   rtp += rtp_hdr_len_without_extn;
 
   // Getting extension profile ID and length.
-  uint16 profile_id = talk_base::GetBE16(rtp);
+  uint16 profile_id = rtc::GetBE16(rtp);
   // Length is in 32 bit words.
-  uint16 extn_length = talk_base::GetBE16(rtp + 2) * 4;
+  uint16 extn_length = rtc::GetBE16(rtp + 2) * 4;
 
   rtp += kRtpExtnHdrLen;  // Moving past extn header.
 
   bool found = false;
   // WebRTC is using one byte header extension.
   // TODO(mallinath) - Handle two byte header extension.
   if (profile_id == 0xBEDE) {  // OneByte extension header
     //  0
     //  0 1 2 3 4 5 6 7
     // +-+-+-+-+-+-+-+-+
@@ skipping 208 matching lines @@
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           base::Bind(packet_dump_callback_,
                                      Passed(&packet_header),
                                      header_length,
                                      packet_length,
                                      incoming));
 }
 
 }  // namespace content