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

media/cast/rtcp/rtcp_utility.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/rtcp/rtcp_utility.h"
 
+#include "base/big_endian.h"
 #include "base/logging.h"
 #include "media/cast/transport/cast_transport_defines.h"
-#include "net/base/big_endian.h"
 
 namespace media {
 namespace cast {
 
 RtcpParser::RtcpParser(const uint8* rtcpData, size_t rtcpDataLength)
     : rtcp_data_begin_(rtcpData),
       rtcp_data_end_(rtcpData + rtcpDataLength),
       valid_packet_(false),
       rtcp_data_(rtcpData),
       rtcp_block_end_(NULL),
@@ skipping 282 matching lines @@
   return true;
 }
 
 bool RtcpParser::ParseRR() {
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
   if (length < 8)
     return false;
 
   field_type_ = kRtcpRrCode;
 
-  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_data_), length);
   big_endian_reader.Skip(4);  // Skip header
   big_endian_reader.ReadU32(&field_.receiver_report.sender_ssrc);
   field_.receiver_report.number_of_report_blocks = number_of_blocks_;
   rtcp_data_ += 8;
 
   // State transition
   state_ = kStateReportBlock;
   return true;
 }
 
 bool RtcpParser::ParseSR() {
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
   if (length < 28) {
     EndCurrentBlock();
     return false;
   }
   field_type_ = kRtcpSrCode;
 
-  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_data_), length);
   big_endian_reader.Skip(4);  // Skip header
   big_endian_reader.ReadU32(&field_.sender_report.sender_ssrc);
   big_endian_reader.ReadU32(&field_.sender_report.ntp_most_significant);
   big_endian_reader.ReadU32(&field_.sender_report.ntp_least_significant);
   big_endian_reader.ReadU32(&field_.sender_report.rtp_timestamp);
   big_endian_reader.ReadU32(&field_.sender_report.sender_packet_count);
   big_endian_reader.ReadU32(&field_.sender_report.sender_octet_count);
   field_.sender_report.number_of_report_blocks = number_of_blocks_;
   rtcp_data_ += 28;
 
   if (number_of_blocks_ != 0) {
     // State transition.
     state_ = kStateReportBlock;
   } else {
     // Don't go to state report block item if 0 report blocks.
     state_ = kStateTopLevel;
     EndCurrentBlock();
   }
   return true;
 }
 
 bool RtcpParser::ParseReportBlockItem() {
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
   if (length < 24 || number_of_blocks_ <= 0) {
     state_ = kStateTopLevel;
     EndCurrentBlock();
     return false;
   }
 
-  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_data_), length);
   big_endian_reader.ReadU32(&field_.report_block_item.ssrc);
   big_endian_reader.ReadU8(&field_.report_block_item.fraction_lost);
 
   uint8 temp_number_of_packets_lost;
   big_endian_reader.ReadU8(&temp_number_of_packets_lost);
   field_.report_block_item.cumulative_number_of_packets_lost =
       temp_number_of_packets_lost << 16;
   big_endian_reader.ReadU8(&temp_number_of_packets_lost);
   field_.report_block_item.cumulative_number_of_packets_lost +=
       temp_number_of_packets_lost << 8;
@@ skipping 39 matching lines @@
   // Find c_name item in a Sdes chunk.
   while (rtcp_data_ < rtcp_block_end_) {
     ptrdiff_t data_length = rtcp_block_end_ - rtcp_data_;
     if (data_length < 4) {
       state_ = kStateTopLevel;
       EndCurrentBlock();
       return false;
     }
 
     uint32 ssrc;
-    net::BigEndianReader big_endian_reader(rtcp_data_, data_length);
+    base::BigEndianReader big_endian_reader(
+        reinterpret_cast<const char*>(rtcp_data_), data_length);
     big_endian_reader.ReadU32(&ssrc);
     rtcp_data_ += 4;
 
     bool found_c_name = ParseSdesTypes();
     if (found_c_name) {
       field_.c_name.sender_ssrc = ssrc;
       return true;
     }
   }
   state_ = kStateTopLevel;
   EndCurrentBlock();
   return false;
 }
 
 bool RtcpParser::ParseSdesTypes() {
   // Only the c_name item is mandatory. RFC 3550 page 46.
   bool found_c_name = false;
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
-  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_data_), length);
 
   while (big_endian_reader.remaining() > 0) {
     uint8 tag;
     big_endian_reader.ReadU8(&tag);
 
     if (tag == 0) {
       // End tag! 4 octet aligned.
       rtcp_data_ = rtcp_block_end_;
       return found_c_name;
     }
@@ skipping 45 matching lines @@
 bool RtcpParser::ParseByeItem() {
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
   if (length < 4 || number_of_blocks_ == 0) {
     state_ = kStateTopLevel;
     EndCurrentBlock();
     return false;
   }
 
   field_type_ = kRtcpByeCode;
 
-  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_data_), length);
   big_endian_reader.ReadU32(&field_.bye.sender_ssrc);
   rtcp_data_ += 4;
 
   // We can have several CSRCs attached.
   if (length >= 4 * number_of_blocks_) {
     rtcp_data_ += (number_of_blocks_ - 1) * 4;
   }
   number_of_blocks_ = 0;
   return true;
 }
 
 bool RtcpParser::ParseApplicationDefined(uint8 subtype) {
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
   if (length < 16 ||
       !(subtype == kSenderLogSubtype || subtype == kReceiverLogSubtype)) {
     state_ = kStateTopLevel;
     EndCurrentBlock();
     return false;
   }
 
   uint32 sender_ssrc;
   uint32 name;
 
-  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_data_), length);
   big_endian_reader.Skip(4);  // Skip header.
   big_endian_reader.ReadU32(&sender_ssrc);
   big_endian_reader.ReadU32(&name);
 
   if (name != kCast) {
     state_ = kStateTopLevel;
     EndCurrentBlock();
     return false;
   }
   rtcp_data_ += 12;
@@ skipping 16 matching lines @@
 
 bool RtcpParser::ParseCastReceiverLogFrameItem() {
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
   if (length < 12) {
     state_ = kStateTopLevel;
     EndCurrentBlock();
     return false;
   }
   uint32 rtp_timestamp;
   uint32 data;
-  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_data_), length);
   big_endian_reader.ReadU32(&rtp_timestamp);
   big_endian_reader.ReadU32(&data);
 
   rtcp_data_ += 8;
 
   field_.cast_receiver_log.rtp_timestamp = rtp_timestamp;
   // We have 24 LSB of the event timestamp base on the wire.
   field_.cast_receiver_log.event_timestamp_base = data & 0xffffff;
 
   number_of_blocks_ = 1 + static_cast<uint8>(data >> 24);
@@ skipping 11 matching lines @@
   }
   if (number_of_blocks_ == 0) {
     // Continue parsing the next receiver frame event.
     state_ = kStateApplicationSpecificCastReceiverFrameLog;
     return false;
   }
   number_of_blocks_--;
 
   uint16 delay_delta_or_packet_id;
   uint16 event_type_and_timestamp_delta;
-  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_data_), length);
   big_endian_reader.ReadU16(&delay_delta_or_packet_id);
   big_endian_reader.ReadU16(&event_type_and_timestamp_delta);
 
   rtcp_data_ += 4;
 
   field_.cast_receiver_log.event =
       static_cast<uint8>(event_type_and_timestamp_delta >> 12);
   field_.cast_receiver_log.delay_delta_or_packet_id = delay_delta_or_packet_id;
   field_.cast_receiver_log.event_timestamp_delta =
       event_type_and_timestamp_delta & 0xfff;
 
   field_type_ = kRtcpApplicationSpecificCastReceiverLogEventCode;
   return true;
 }
 
 bool RtcpParser::ParseCastSenderLogItem() {
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
 
   if (length < 4) {
     state_ = kStateTopLevel;
     EndCurrentBlock();
     return false;
   }
   uint32 data;
-  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_data_), length);
   big_endian_reader.ReadU32(&data);
 
   rtcp_data_ += 4;
 
   field_.cast_sender_log.status = static_cast<uint8>(data >> 24);
   // We have 24 LSB of the RTP timestamp on the wire.
   field_.cast_sender_log.rtp_timestamp = data & 0xffffff;
   field_type_ = kRtcpApplicationSpecificCastSenderLogCode;
   return true;
 }
 
 bool RtcpParser::ParseFeedBackCommon(const RtcpCommonHeader& header) {
   DCHECK((header.PT == transport::kPacketTypeGenericRtpFeedback) ||
          (header.PT == transport::kPacketTypePayloadSpecific))
       << "Invalid state";
 
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
 
   if (length < 12) {  // 4 * 3, RFC4585 section 6.1
     EndCurrentBlock();
     return false;
   }
 
   uint32 sender_ssrc;
   uint32 media_ssrc;
-  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_data_), length);
   big_endian_reader.Skip(4);  // Skip header.
   big_endian_reader.ReadU32(&sender_ssrc);
   big_endian_reader.ReadU32(&media_ssrc);
 
   rtcp_data_ += 12;
 
   if (header.PT == transport::kPacketTypeGenericRtpFeedback) {
     // Transport layer feedback
     switch (header.IC) {
       case 1:
@@ skipping 88 matching lines @@
   }
   if (length > 2 + kRtcpRpsiDataSize) {
     state_ = kStateTopLevel;
     EndCurrentBlock();
     return false;
   }
 
   field_type_ = kRtcpPayloadSpecificRpsiCode;
 
   uint8 padding_bits;
-  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_data_), length);
   big_endian_reader.ReadU8(&padding_bits);
   big_endian_reader.ReadU8(&field_.rpsi.payload_type);
   big_endian_reader.ReadBytes(&field_.rpsi.native_bit_string, length - 2);
   field_.rpsi.number_of_valid_bits =
       static_cast<uint16>(length - 2) * 8 - padding_bits;
 
   rtcp_data_ += length;
   return true;
 }
 
 bool RtcpParser::ParseNackItem() {
   // RFC 4585 6.2.1. Generic Nack
 
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
   if (length < 4) {
     state_ = kStateTopLevel;
     EndCurrentBlock();
     return false;
   }
 
   field_type_ = kRtcpGenericRtpFeedbackNackItemCode;
 
-  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_data_), length);
   big_endian_reader.ReadU16(&field_.nack_item.packet_id);
   big_endian_reader.ReadU16(&field_.nack_item.bitmask);
   rtcp_data_ += 4;
   return true;
 }
 
 bool RtcpParser::ParsePayloadSpecificAppItem() {
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
 
   if (length < 4) {
     state_ = kStateTopLevel;
     EndCurrentBlock();
     return false;
   }
   uint32 name;
-  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_data_), length);
   big_endian_reader.ReadU32(&name);
   rtcp_data_ += 4;
 
   if (name == kRemb) {
     field_type_ = kRtcpPayloadSpecificRembCode;
     state_ = kStatePayloadSpecificRemb;
     return true;
   } else if (name == kCast) {
     field_type_ = kRtcpPayloadSpecificCastCode;
     state_ = kStatePayloadSpecificCast;
     return true;
   }
   state_ = kStateTopLevel;
   EndCurrentBlock();
   return false;
 }
 
 bool RtcpParser::ParsePayloadSpecificRembItem() {
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
 
   if (length < 4) {
     state_ = kStateTopLevel;
     EndCurrentBlock();
     return false;
   }
 
-  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_data_), length);
   big_endian_reader.ReadU8(&field_.remb_item.number_of_ssrcs);
 
   uint8 byte_1;
   uint8 byte_2;
   uint8 byte_3;
   big_endian_reader.ReadU8(&byte_1);
   big_endian_reader.ReadU8(&byte_2);
   big_endian_reader.ReadU8(&byte_3);
   rtcp_data_ += 4;
 
@@ skipping 18 matching lines @@
 
 bool RtcpParser::ParsePayloadSpecificCastItem() {
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
   if (length < 4) {
     state_ = kStateTopLevel;
     EndCurrentBlock();
     return false;
   }
   field_type_ = kRtcpPayloadSpecificCastCode;
 
-  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_data_), length);
   big_endian_reader.ReadU8(&field_.cast_item.last_frame_id);
   big_endian_reader.ReadU8(&field_.cast_item.number_of_lost_fields);
 
   rtcp_data_ += 4;
 
   if (field_.cast_item.number_of_lost_fields != 0) {
     // State transition
     state_ = kStatePayloadSpecificCastNack;
   } else {
     // Don't go to state cast nack item if got 0 fields.
     state_ = kStateTopLevel;
     EndCurrentBlock();
   }
   return true;
 }
 
 bool RtcpParser::ParsePayloadSpecificCastNackItem() {
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
   if (length < 4) {
     state_ = kStateTopLevel;
     EndCurrentBlock();
     return false;
   }
   field_type_ = kRtcpPayloadSpecificCastNackItemCode;
 
-  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_data_), length);
   big_endian_reader.ReadU8(&field_.cast_nack_item.frame_id);
   big_endian_reader.ReadU16(&field_.cast_nack_item.packet_id);
   big_endian_reader.ReadU8(&field_.cast_nack_item.bitmask);
 
   rtcp_data_ += 4;
   return true;
 }
 
 bool RtcpParser::ParseFirItem() {
   // RFC 5104 4.3.1. Full Intra Request (fir)
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
 
   if (length < 8) {
     state_ = kStateTopLevel;
     EndCurrentBlock();
     return false;
   }
   field_type_ = kRtcpPayloadSpecificFirItemCode;
 
-  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_data_), length);
   big_endian_reader.ReadU32(&field_.fir_item.ssrc);
   big_endian_reader.ReadU8(&field_.fir_item.command_sequence_number);
 
   rtcp_data_ += 8;
   return true;
 }
 
 bool RtcpParser::ParseExtendedReport() {
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
   if (length < 8)
     return false;
 
   field_type_ = kRtcpXrCode;
 
-  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_data_), length);
   big_endian_reader.Skip(4);  // Skip header.
   big_endian_reader.ReadU32(&field_.extended_report.sender_ssrc);
 
   rtcp_data_ += 8;
 
   state_ = kStateExtendedReportBlock;
   return true;
 }
 
 bool RtcpParser::ParseExtendedReportItem() {
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
   if (length < 4) {
     state_ = kStateTopLevel;
     EndCurrentBlock();
     return false;
   }
 
   uint8 block_type;
   uint16 block_length;
-  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_data_), length);
   big_endian_reader.ReadU8(&block_type);
   big_endian_reader.Skip(1);  // Ignore reserved.
   big_endian_reader.ReadU16(&block_length);
 
   rtcp_data_ += 4;
 
   switch (block_type) {
     case 4:
       if (block_length != 2) {
         // Invalid block length.
@@ skipping 28 matching lines @@
 }
 
 bool RtcpParser::ParseExtendedReportReceiverReferenceTimeReport() {
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
   if (length < 8) {
     state_ = kStateTopLevel;
     EndCurrentBlock();
     return false;
   }
 
-  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_data_), length);
   big_endian_reader.ReadU32(&field_.rrtr.ntp_most_significant);
   big_endian_reader.ReadU32(&field_.rrtr.ntp_least_significant);
 
   rtcp_data_ += 8;
 
   field_type_ = kRtcpXrRrtrCode;
   return true;
 }
 
 bool RtcpParser::ParseExtendedReportDelaySinceLastReceiverReport() {
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
   if (length < 12) {
     state_ = kStateTopLevel;
     EndCurrentBlock();
     return false;
   }
   if (number_of_blocks_ == 0) {
     // Continue parsing the extended report block.
     state_ = kStateExtendedReportBlock;
     return false;
   }
 
-  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_data_), length);
   big_endian_reader.ReadU32(&field_.dlrr.receivers_ssrc);
   big_endian_reader.ReadU32(&field_.dlrr.last_receiver_report);
   big_endian_reader.ReadU32(&field_.dlrr.delay_last_receiver_report);
 
   rtcp_data_ += 12;
 
   number_of_blocks_--;
   field_type_ = kRtcpXrDlrrCode;
   return true;
 }
 
 }  // namespace cast
 }  // namespace media