Switch to standard integer types in media/.

media/cast/net/rtcp/rtcp_builder.cc

 // Copyright 2014 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/net/rtcp/rtcp_builder.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <vector>
 
 #include "base/logging.h"
 #include "media/cast/net/rtcp/rtcp_utility.h"
 
 namespace media {
 namespace cast {
 namespace {
 
 // Max delta is 4095 milliseconds because we need to be able to encode it in
 // 12 bits.
-const int64 kMaxWireFormatTimeDeltaMs = INT64_C(0xfff);
+const int64_t kMaxWireFormatTimeDeltaMs = INT64_C(0xfff);
 
-uint16 MergeEventTypeAndTimestampForWireFormat(
+uint16_t MergeEventTypeAndTimestampForWireFormat(
     const CastLoggingEvent& event,
     const base::TimeDelta& time_delta) {
-  int64 time_delta_ms = time_delta.InMilliseconds();
+  int64_t time_delta_ms = time_delta.InMilliseconds();
 
   DCHECK_GE(time_delta_ms, 0);
   DCHECK_LE(time_delta_ms, kMaxWireFormatTimeDeltaMs);
 
-  uint16 time_delta_12_bits =
-      static_cast<uint16>(time_delta_ms & kMaxWireFormatTimeDeltaMs);
+  uint16_t time_delta_12_bits =
+      static_cast<uint16_t>(time_delta_ms & kMaxWireFormatTimeDeltaMs);
 
-  uint16 event_type_4_bits = ConvertEventTypeToWireFormat(event);
+  uint16_t event_type_4_bits = ConvertEventTypeToWireFormat(event);
   DCHECK(event_type_4_bits);
   DCHECK(~(event_type_4_bits & 0xfff0));
   return (event_type_4_bits << 12) | time_delta_12_bits;
 }
 
 bool EventTimestampLessThan(const RtcpReceiverEventLogMessage& lhs,
                             const RtcpReceiverEventLogMessage& rhs) {
   return lhs.event_timestamp < rhs.event_timestamp;
 }
 
@@ skipping 62 matching lines @@
  private:
   std::ostringstream stream_;
   int frame_count_;
   int packet_count_;
   int last_frame_id_;
   int last_packet_id_;
   bool contiguous_sequence_;
 };
 }  // namespace
 
-RtcpBuilder::RtcpBuilder(uint32 sending_ssrc)
-    : writer_(NULL, 0),
-      ssrc_(sending_ssrc),
-      ptr_of_length_(NULL) {
-}
+RtcpBuilder::RtcpBuilder(uint32_t sending_ssrc)
+    : writer_(NULL, 0), ssrc_(sending_ssrc), ptr_of_length_(NULL) {}
 
 RtcpBuilder::~RtcpBuilder() {}
 
 void RtcpBuilder::PatchLengthField() {
   if (ptr_of_length_) {
     // Back-patch the packet length. The client must have taken
     // care of proper padding to 32-bit words.
     int this_packet_length = (writer_.ptr() - ptr_of_length_ - 2);
     DCHECK_EQ(0, this_packet_length % 4)
         << "Packets must be a multiple of 32 bits long";
@@ skipping 98 matching lines @@
   writer_.WriteU32(rrtr->ntp_fraction);
 }
 
 void RtcpBuilder::AddCast(const RtcpCastMessage* cast,
                           base::TimeDelta target_delay) {
   // See RTC 4585 Section 6.4 for application specific feedback messages.
   AddRtcpHeader(kPacketTypePayloadSpecific, 15);
   writer_.WriteU32(ssrc_);              // Add our own SSRC.
   writer_.WriteU32(cast->media_ssrc);  // Remote SSRC.
   writer_.WriteU32(kCast);
-  writer_.WriteU8(static_cast<uint8>(cast->ack_frame_id));
-  uint8* cast_loss_field_pos = reinterpret_cast<uint8*>(writer_.ptr());
+  writer_.WriteU8(static_cast<uint8_t>(cast->ack_frame_id));
+  uint8_t* cast_loss_field_pos = reinterpret_cast<uint8_t*>(writer_.ptr());
   writer_.WriteU8(0);  // Overwritten with number_of_loss_fields.
   DCHECK_LE(target_delay.InMilliseconds(),
             std::numeric_limits<uint16_t>::max());
   writer_.WriteU16(target_delay.InMilliseconds());
 
   size_t number_of_loss_fields = 0;
   size_t max_number_of_loss_fields = std::min<size_t>(
       kRtcpMaxCastLossFields, writer_.remaining() / 4);
 
   MissingFramesAndPacketsMap::const_iterator frame_it =
       cast->missing_frames_and_packets.begin();
 
   NackStringBuilder nack_string_builder;
   for (; frame_it != cast->missing_frames_and_packets.end() &&
              number_of_loss_fields < max_number_of_loss_fields;
        ++frame_it) {
     nack_string_builder.PushFrame(frame_it->first);
     // Iterate through all frames with missing packets.
     if (frame_it->second.empty()) {
       // Special case all packets in a frame is missing.
-      writer_.WriteU8(static_cast<uint8>(frame_it->first));
+      writer_.WriteU8(static_cast<uint8_t>(frame_it->first));
       writer_.WriteU16(kRtcpCastAllPacketsLost);
       writer_.WriteU8(0);
       nack_string_builder.PushPacket(kRtcpCastAllPacketsLost);
       ++number_of_loss_fields;
     } else {
       PacketIdSet::const_iterator packet_it = frame_it->second.begin();
       while (packet_it != frame_it->second.end()) {
-        uint16 packet_id = *packet_it;
+        uint16_t packet_id = *packet_it;
         // Write frame and packet id to buffer before calculating bitmask.
-        writer_.WriteU8(static_cast<uint8>(frame_it->first));
+        writer_.WriteU8(static_cast<uint8_t>(frame_it->first));
         writer_.WriteU16(packet_id);
         nack_string_builder.PushPacket(packet_id);
 
-        uint8 bitmask = 0;
+        uint8_t bitmask = 0;
         ++packet_it;
         while (packet_it != frame_it->second.end()) {
-          int shift = static_cast<uint8>(*packet_it - packet_id) - 1;
+          int shift = static_cast<uint8_t>(*packet_it - packet_id) - 1;
           if (shift >= 0 && shift <= 7) {
             nack_string_builder.PushPacket(*packet_it);
             bitmask |= (1 << shift);
             ++packet_it;
           } else {
             break;
           }
         }
         writer_.WriteU8(bitmask);
         ++number_of_loss_fields;
       }
     }
   }
   VLOG_IF(1, !nack_string_builder.Empty())
       << "SSRC: " << cast->media_ssrc
       << ", ACK: " << cast->ack_frame_id
       << ", NACK: " << nack_string_builder.GetString();
   DCHECK_LE(number_of_loss_fields, kRtcpMaxCastLossFields);
-  *cast_loss_field_pos = static_cast<uint8>(number_of_loss_fields);
+  *cast_loss_field_pos = static_cast<uint8_t>(number_of_loss_fields);
 }
 
 void RtcpBuilder::AddSR(const RtcpSenderInfo& sender_info) {
   AddRtcpHeader(kPacketTypeSenderReport, 0);
   writer_.WriteU32(ssrc_);
   writer_.WriteU32(sender_info.ntp_seconds);
   writer_.WriteU32(sender_info.ntp_fraction);
   writer_.WriteU32(sender_info.rtp_timestamp);
   writer_.WriteU32(sender_info.send_packet_count);
-  writer_.WriteU32(static_cast<uint32>(sender_info.send_octet_count));
+  writer_.WriteU32(static_cast<uint32_t>(sender_info.send_octet_count));
 }
 
 /*
    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
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |V=2|P|reserved |   PT=XR=207   |             length            |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |                              SSRC                             |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
@@ skipping 41 matching lines @@
     writer_.WriteU32(frame_log_messages.rtp_timestamp_);
     size_t messages_in_frame = frame_log_messages.event_log_messages_.size();
     if (messages_in_frame > total_number_of_messages_to_send) {
       // We are running out of space.
       messages_in_frame = total_number_of_messages_to_send;
     }
     // Keep track of how many messages we have left to send.
     total_number_of_messages_to_send -= messages_in_frame;
 
     // On the wire format is number of messages - 1.
-    writer_.WriteU8(static_cast<uint8>(messages_in_frame - 1));
+    writer_.WriteU8(static_cast<uint8_t>(messages_in_frame - 1));
 
     base::TimeTicks event_timestamp_base =
         frame_log_messages.event_log_messages_.front().event_timestamp;
-    uint32 base_timestamp_ms =
+    uint32_t base_timestamp_ms =
         (event_timestamp_base - base::TimeTicks()).InMilliseconds();
-    writer_.WriteU8(static_cast<uint8>(base_timestamp_ms >> 16));
-    writer_.WriteU8(static_cast<uint8>(base_timestamp_ms >> 8));
-    writer_.WriteU8(static_cast<uint8>(base_timestamp_ms));
+    writer_.WriteU8(static_cast<uint8_t>(base_timestamp_ms >> 16));
+    writer_.WriteU8(static_cast<uint8_t>(base_timestamp_ms >> 8));
+    writer_.WriteU8(static_cast<uint8_t>(base_timestamp_ms));
 
     while (!frame_log_messages.event_log_messages_.empty() &&
            messages_in_frame > 0) {
       const RtcpReceiverEventLogMessage& event_message =
           frame_log_messages.event_log_messages_.front();
-      uint16 event_type_and_timestamp_delta =
+      uint16_t event_type_and_timestamp_delta =
           MergeEventTypeAndTimestampForWireFormat(
               event_message.type,
               event_message.event_timestamp - event_timestamp_base);
       switch (event_message.type) {
         case FRAME_ACK_SENT:
         case FRAME_PLAYOUT:
         case FRAME_DECODED:
-          writer_.WriteU16(
-              static_cast<uint16>(event_message.delay_delta.InMilliseconds()));
+          writer_.WriteU16(static_cast<uint16_t>(
+              event_message.delay_delta.InMilliseconds()));
           writer_.WriteU16(event_type_and_timestamp_delta);
           break;
         case PACKET_RECEIVED:
           writer_.WriteU16(event_message.packet_id);
           writer_.WriteU16(event_type_and_timestamp_delta);
           break;
         default:
           NOTREACHED();
       }
       messages_in_frame--;
@@ skipping 76 matching lines @@
     receiver_log_message->push_front(frame_log);
   }
 
   VLOG(3) << "number of frames: " << number_of_frames;
   VLOG(3) << "total messages to send: " << *total_number_of_messages_to_send;
   return number_of_frames > 0;
 }
 
 }  // namespace cast
 }  // namespace media