Switch to standard integer types in media/.

media/cast/logging/log_serializer.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.
 //
 // The serialization format is as follows:
 //   16-bit integer describing the following LogMetadata proto size in bytes.
 //   The LogMetadata proto.
 //   32-bit integer describing number of frame events.
 //   (The following repeated for number of frame events):
 //     16-bit integer describing the following AggregatedFrameEvent proto size
@@ skipping 29 matching lines @@
 bool DoSerializeEvents(const LogMetadata& metadata,
                        const FrameEventList& frame_events,
                        const PacketEventList& packet_events,
                        const int max_output_bytes,
                        char* output,
                        int* output_bytes) {
   base::BigEndianWriter writer(output, max_output_bytes);
 
   int proto_size = metadata.ByteSize();
   DCHECK(proto_size <= kMaxSerializedProtoBytes);
-  if (!writer.WriteU16(static_cast<uint16>(proto_size)))
+  if (!writer.WriteU16(static_cast<uint16_t>(proto_size)))
     return false;
   if (!metadata.SerializeToArray(writer.ptr(), writer.remaining()))
     return false;
   if (!writer.Skip(proto_size))
     return false;
 
   RtpTimestamp prev_rtp_timestamp = 0;
   for (media::cast::FrameEventList::const_iterator it = frame_events.begin();
        it != frame_events.end();
        ++it) {
     media::cast::proto::AggregatedFrameEvent frame_event(**it);
 
     // Adjust relative RTP timestamp so that it is relative to previous frame,
     // rather than relative to first RTP timestamp.
     // This is done to improve encoding size.
     RtpTimestamp old_relative_rtp_timestamp =
         frame_event.relative_rtp_timestamp();
     frame_event.set_relative_rtp_timestamp(
         old_relative_rtp_timestamp - prev_rtp_timestamp);
     prev_rtp_timestamp = old_relative_rtp_timestamp;
 
     proto_size = frame_event.ByteSize();
     DCHECK(proto_size <= kMaxSerializedProtoBytes);
 
     // Write size of the proto, then write the proto.
-    if (!writer.WriteU16(static_cast<uint16>(proto_size)))
+    if (!writer.WriteU16(static_cast<uint16_t>(proto_size)))
       return false;
     if (!frame_event.SerializeToArray(writer.ptr(), writer.remaining()))
       return false;
     if (!writer.Skip(proto_size))
       return false;
   }
 
   // Write packet events.
   prev_rtp_timestamp = 0;
   for (media::cast::PacketEventList::const_iterator it = packet_events.begin();
        it != packet_events.end();
        ++it) {
     media::cast::proto::AggregatedPacketEvent packet_event(**it);
     RtpTimestamp old_relative_rtp_timestamp =
         packet_event.relative_rtp_timestamp();
     packet_event.set_relative_rtp_timestamp(
         old_relative_rtp_timestamp - prev_rtp_timestamp);
     prev_rtp_timestamp = old_relative_rtp_timestamp;
 
     proto_size = packet_event.ByteSize();
     DCHECK(proto_size <= kMaxSerializedProtoBytes);
 
     // Write size of the proto, then write the proto.
-    if (!writer.WriteU16(static_cast<uint16>(proto_size)))
+    if (!writer.WriteU16(static_cast<uint16_t>(proto_size)))
       return false;
     if (!packet_event.SerializeToArray(writer.ptr(), writer.remaining()))
       return false;
     if (!writer.Skip(proto_size))
       return false;
   }
 
   *output_bytes = max_output_bytes - writer.remaining();
   return true;
 }
 
 bool Compress(char* uncompressed_buffer,
               int uncompressed_bytes,
               int max_output_bytes,
               char* output,
               int* output_bytes) {
   z_stream stream = {0};
   int result = deflateInit2(&stream,
                             Z_DEFAULT_COMPRESSION,
                             Z_DEFLATED,
                             // 16 is added to produce a gzip header + trailer.
                             MAX_WBITS + 16,
                             8,  // memLevel = 8 is default.
                             Z_DEFAULT_STRATEGY);
   DCHECK_EQ(Z_OK, result);
 
-  stream.next_in = reinterpret_cast<uint8*>(uncompressed_buffer);
+  stream.next_in = reinterpret_cast<uint8_t*>(uncompressed_buffer);
   stream.avail_in = uncompressed_bytes;
-  stream.next_out = reinterpret_cast<uint8*>(output);
+  stream.next_out = reinterpret_cast<uint8_t*>(output);
   stream.avail_out = max_output_bytes;
 
   // Do a one-shot compression. This will return Z_STREAM_END only if |output|
   // is large enough to hold all compressed data.
   result = deflate(&stream, Z_FINISH);
   bool success = (result == Z_STREAM_END);
 
   if (!success)
     DVLOG(2) << "deflate() failed. Result: " << result;
 
@@ skipping 41 matching lines @@
                              frame_events,
                              packet_events,
                              max_output_bytes,
                              output,
                              output_bytes);
   }
 }
 
 }  // namespace cast
 }  // namespace media