ui/base/resource: Roll our own version of ReadBigEndian() function.

media/cast/transport/rtcp/rtcp_builder.cc

 // Copyright 2013 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 "media/cast/transport/rtcp/rtcp_builder.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
+#include "base/big_endian.h"
 #include "base/logging.h"
 #include "media/cast/transport/cast_transport_defines.h"
 #include "media/cast/transport/pacing/paced_sender.h"
-#include "net/base/big_endian.h"
 
 static const size_t kRtcpCastLogHeaderSize = 12;
 static const size_t kRtcpSenderFrameLogSize = 4;
 
 namespace media {
 namespace cast {
 namespace transport {
 
 namespace {
 // RFC 3550 page 44, including end null.
@@ skipping 51 matching lines @@
 void RtcpBuilder::BuildSR(const RtcpSenderInfo& sender_info,
                           Packet* packet) const {
   // Sender report.
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 52, kMaxIpPacketSize) << "Not enough buffer space";
   if (start_size + 52 > kMaxIpPacketSize) return;
 
   uint16 number_of_rows = 6;
   packet->resize(start_size + 28);
 
-  net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 28);
+  base::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 28);
   big_endian_writer.WriteU8(0x80);
   big_endian_writer.WriteU8(kPacketTypeSenderReport);
   big_endian_writer.WriteU16(number_of_rows);
   big_endian_writer.WriteU32(ssrc_);
   big_endian_writer.WriteU32(sender_info.ntp_seconds);
   big_endian_writer.WriteU32(sender_info.ntp_fraction);
   big_endian_writer.WriteU32(sender_info.rtp_timestamp);
   big_endian_writer.WriteU32(sender_info.send_packet_count);
   big_endian_writer.WriteU32(static_cast<uint32>(sender_info.send_octet_count));
 }
 
 void RtcpBuilder::BuildSdec(Packet* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size +  12 + c_name_.length(), kMaxIpPacketSize)
       << "Not enough buffer space";
   if (start_size + 12 > kMaxIpPacketSize) return;
 
   // SDES Source Description.
   packet->resize(start_size + 10);
 
-  net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 10);
+  base::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 10);
   // We always need to add one SDES CNAME.
   big_endian_writer.WriteU8(0x80 + 1);
   big_endian_writer.WriteU8(kPacketTypeSdes);
 
   // Handle SDES length later on.
   uint32 sdes_length_position = static_cast<uint32>(start_size) + 3;
   big_endian_writer.WriteU16(0);
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU8(1);  // CNAME = 1
   big_endian_writer.WriteU8(static_cast<uint8>(c_name_.length()));
@@ skipping 20 matching lines @@
   (*packet)[sdes_length_position] = buffer_length;
 }
 
 void RtcpBuilder::BuildBye(Packet* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 8, kMaxIpPacketSize) << "Not enough buffer space";
   if (start_size + 8 > kMaxIpPacketSize) return;
 
   packet->resize(start_size + 8);
 
-  net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 8);
+  base::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 8);
   big_endian_writer.WriteU8(0x80 + 1);
   big_endian_writer.WriteU8(kPacketTypeBye);
   big_endian_writer.WriteU16(1);  // Length.
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
 }
 
 /*
    0                   1                   2                   3
    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
@@ skipping 11 matching lines @@
   +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
 */
 void RtcpBuilder::BuildDlrrRb(const RtcpDlrrReportBlock& dlrr,
                               Packet* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 24, kMaxIpPacketSize) << "Not enough buffer space";
   if (start_size + 24 > kMaxIpPacketSize) return;
 
   packet->resize(start_size + 24);
 
-  net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 24);
+  base::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 24);
   big_endian_writer.WriteU8(0x80);
   big_endian_writer.WriteU8(kPacketTypeXr);
   big_endian_writer.WriteU16(5);  // Length.
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU8(5);  // Add block type.
   big_endian_writer.WriteU8(0);  // Add reserved.
   big_endian_writer.WriteU16(3);  // Block length.
   big_endian_writer.WriteU32(ssrc_);  // Add the media (received RTP) SSRC.
   big_endian_writer.WriteU32(dlrr.last_rr);
   big_endian_writer.WriteU32(dlrr.delay_since_last_rr);
@@ skipping 11 matching lines @@
 
   size_t space_for_x_messages =
       (remaining_space - kRtcpCastLogHeaderSize) / kRtcpSenderFrameLogSize;
   size_t number_of_messages = std::min(space_for_x_messages,
                                        sender_log_message.size());
 
   size_t log_size = kRtcpCastLogHeaderSize +
       number_of_messages * kRtcpSenderFrameLogSize;
   packet->resize(start_size + log_size);
 
-  net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), log_size);
+  base::BigEndianWriter big_endian_writer(&((*packet)[start_size]), log_size);
   big_endian_writer.WriteU8(0x80 + kSenderLogSubtype);
   big_endian_writer.WriteU8(kPacketTypeApplicationDefined);
   big_endian_writer.WriteU16(static_cast<uint16>(2 + number_of_messages));
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU32(kCast);
 
   std::list<RtcpSenderFrameLogMessage>::const_iterator it =
       sender_log_message.begin();
   for (; number_of_messages > 0; --number_of_messages) {
     DCHECK(!sender_log_message.empty());
     const RtcpSenderFrameLogMessage& message = *it;
     big_endian_writer.WriteU8(static_cast<uint8>(message.frame_status));
     // We send the 24 east significant bits of the RTP timestamp.
     big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp >> 16));
     big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp >> 8));
     big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp));
     ++it;
   }
 }
 
 }  // namespace transport
 }  // namespace cast
 }  // namespace media