Switch to standard integer types in media/.

media/formats/webm/webm_cluster_parser.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/formats/webm/webm_cluster_parser.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/sys_byteorder.h"
@@ skipping 14 matching lines @@
 enum {
   // Limits the number of MEDIA_LOG() calls in the path of reading encoded
   // duration to avoid spamming for corrupted data.
   kMaxDurationErrorLogs = 10,
   // Limits the number of MEDIA_LOG() calls warning the user that buffer
   // durations have been estimated.
   kMaxDurationEstimateLogs = 10,
 };
 
 WebMClusterParser::WebMClusterParser(
-    int64 timecode_scale,
+    int64_t timecode_scale,
     int audio_track_num,
     base::TimeDelta audio_default_duration,
     int video_track_num,
     base::TimeDelta video_default_duration,
     const WebMTracksParser::TextTracks& text_tracks,
-    const std::set<int64>& ignored_tracks,
+    const std::set<int64_t>& ignored_tracks,
     const std::string& audio_encryption_key_id,
     const std::string& video_encryption_key_id,
     const AudioCodec audio_codec,
     const scoped_refptr<MediaLog>& media_log)
     : timecode_multiplier_(timecode_scale / 1000.0),
       ignored_tracks_(ignored_tracks),
       audio_encryption_key_id_(audio_encryption_key_id),
       video_encryption_key_id_(video_encryption_key_id),
       audio_codec_(audio_codec),
       parser_(kWebMIdCluster, this),
@@ skipping 234 matching lines @@
   block_data_size_ = -1;
   block_duration_ = -1;
   block_add_id_ = -1;
   block_additional_data_.reset();
   block_additional_data_size_ = 0;
   discard_padding_ = -1;
   discard_padding_set_ = false;
   return result;
 }
 
-bool WebMClusterParser::OnUInt(int id, int64 val) {
-  int64* dst;
+bool WebMClusterParser::OnUInt(int id, int64_t val) {
+  int64_t* dst;
   switch (id) {
     case kWebMIdTimecode:
       dst = &cluster_timecode_;
       break;
     case kWebMIdBlockDuration:
       dst = &block_duration_;
       break;
     case kWebMIdBlockAddID:
       dst = &block_add_id_;
       break;
     default:
       return true;
   }
   if (*dst != -1)
     return false;
   *dst = val;
   return true;
 }
 
 bool WebMClusterParser::ParseBlock(bool is_simple_block,
                                    const uint8_t* buf,
                                    int size,
                                    const uint8_t* additional,
                                    int additional_size,
                                    int duration,
-                                   int64 discard_padding) {
+                                   int64_t discard_padding) {
   if (size < 4)
     return false;
 
   // Return an error if the trackNum > 127. We just aren't
   // going to support large track numbers right now.
   if (!(buf[0] & 0x80)) {
     MEDIA_LOG(ERROR, media_log_) << "TrackNumber over 127 not supported";
     return false;
   }
 
@@ skipping 30 matching lines @@
             << "More than 1 Block in a BlockGroup is not "
                "supported.";
         return false;
       }
       block_data_.reset(new uint8_t[size]);
       memcpy(block_data_.get(), data, size);
       block_data_size_ = size;
       return true;
 
     case kWebMIdBlockAdditional: {
-      uint64 block_add_id = base::HostToNet64(block_add_id_);
+      uint64_t block_add_id = base::HostToNet64(block_add_id_);
       if (block_additional_data_) {
         // TODO(vigneshv): Technically, more than 1 BlockAdditional is allowed
         // as per matroska spec. But for now we don't have a use case to
         // support parsing of such files. Take a look at this again when such a
         // case arises.
         MEDIA_LOG(ERROR, media_log_) << "More than 1 BlockAdditional in a "
                                         "BlockGroup is not supported.";
         return false;
       }
       // First 8 bytes of side_data in DecoderBuffer is the BlockAddID
       // element's value in Big Endian format. This is done to mimic ffmpeg
       // demuxer's behavior.
       block_additional_data_size_ = size + sizeof(block_add_id);
       block_additional_data_.reset(new uint8_t[block_additional_data_size_]);
       memcpy(block_additional_data_.get(), &block_add_id,
              sizeof(block_add_id));
       memcpy(block_additional_data_.get() + 8, data, size);
       return true;
     }
     case kWebMIdDiscardPadding: {
       if (discard_padding_set_ || size <= 0 || size > 8)
         return false;
       discard_padding_set_ = true;
 
       // Read in the big-endian integer.
-      discard_padding_ = static_cast<int8>(data[0]);
+      discard_padding_ = static_cast<int8_t>(data[0]);
       for (int i = 1; i < size; ++i)
         discard_padding_ = (discard_padding_ << 8) | data[i];
 
       return true;
     }
     default:
       return true;
   }
 }
 
 bool WebMClusterParser::OnBlock(bool is_simple_block,
                                 int track_num,
                                 int timecode,
                                 int block_duration,
                                 int flags,
                                 const uint8_t* data,
                                 int size,
                                 const uint8_t* additional,
                                 int additional_size,
-                                int64 discard_padding) {
+                                int64_t discard_padding) {
   DCHECK_GE(size, 0);
   if (cluster_timecode_ == -1) {
     MEDIA_LOG(ERROR, media_log_) << "Got a block before cluster timecode.";
     return false;
   }
 
   // TODO(acolwell): Should relative negative timecode offsets be rejected?  Or
   // only when the absolute timecode is negative?  See http://crbug.com/271794
   if (timecode < 0) {
     MEDIA_LOG(ERROR, media_log_) << "Got a block with negative timecode offset "
@@ skipping 442 matching lines @@
 WebMClusterParser::FindTextTrack(int track_num) {
   const TextTrackMap::iterator it = text_track_map_.find(track_num);
 
   if (it == text_track_map_.end())
     return NULL;
 
   return &it->second;
 }
 
 }  // namespace media