Switch to standard integer types in media/.

media/cast/logging/log_deserializer.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/logging/log_deserializer.h"
 
 #include <utility>
 
 #include "base/big_endian.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 54 matching lines @@
     to->set_target_bitrate(from.target_bitrate());
 }
 
 bool PopulateDeserializedLog(base::BigEndianReader* reader,
                              media::cast::DeserializedLog* log) {
   FrameEventMap frame_event_map;
   PacketEventMap packet_event_map;
 
   int num_frame_events = log->metadata.num_frame_events();
   RtpTimestamp relative_rtp_timestamp = 0;
-  uint16 proto_size = 0;
+  uint16_t proto_size = 0;
   for (int i = 0; i < num_frame_events; i++) {
     if (!reader->ReadU16(&proto_size))
       return false;
 
     linked_ptr<AggregatedFrameEvent> frame_event(new AggregatedFrameEvent);
     if (!frame_event->ParseFromArray(reader->ptr(), proto_size))
       return false;
     if (!reader->Skip(proto_size))
       return false;
 
@@ skipping 53 matching lines @@
 
 bool DoDeserializeEvents(const char* data,
                          int data_bytes,
                          media::cast::DeserializedLog* audio_log,
                          media::cast::DeserializedLog* video_log) {
   bool got_audio = false;
   bool got_video = false;
   base::BigEndianReader reader(data, data_bytes);
 
   LogMetadata metadata;
-  uint16 proto_size = 0;
+  uint16_t proto_size = 0;
   while (reader.remaining() > 0) {
     if (!reader.ReadU16(&proto_size))
       return false;
     if (!metadata.ParseFromArray(reader.ptr(), proto_size))
       return false;
     reader.Skip(proto_size);
 
     if (metadata.is_audio()) {
       if (got_audio) {
         VLOG(1) << "Got audio data twice.";
@@ skipping 19 matching lines @@
   return true;
 }
 
 bool Uncompress(const char* data,
                 int data_bytes,
                 int max_uncompressed_bytes,
                 char* uncompressed,
                 int* uncompressed_bytes) {
   z_stream stream = {0};
 
-  stream.next_in = reinterpret_cast<uint8*>(const_cast<char*>(data));
+  stream.next_in = reinterpret_cast<uint8_t*>(const_cast<char*>(data));
   stream.avail_in = data_bytes;
-  stream.next_out = reinterpret_cast<uint8*>(uncompressed);
+  stream.next_out = reinterpret_cast<uint8_t*>(uncompressed);
   stream.avail_out = max_uncompressed_bytes;
 
   bool success = false;
   while (stream.avail_in > 0 && stream.avail_out > 0) {
     // 16 is added to read in gzip format.
     int result = inflateInit2(&stream, MAX_WBITS + 16);
     DCHECK_EQ(Z_OK, result);
 
     result = inflate(&stream, Z_FINISH);
     success = (result == Z_STREAM_END);
@@ skipping 40 matching lines @@
   } else {
     return DoDeserializeEvents(data, data_bytes, audio_log, video_log);
   }
 }
 
 DeserializedLog::DeserializedLog() {}
 DeserializedLog::~DeserializedLog() {}
 
 }  // namespace cast
 }  // namespace media