Switch to standard integer types in media/.

media/base/stream_parser_buffer.h

 // Copyright (c) 2012 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.
 
 #ifndef MEDIA_BASE_STREAM_PARSER_BUFFER_H_
 #define MEDIA_BASE_STREAM_PARSER_BUFFER_H_
 
 #include <deque>
 
 #include "media/base/decoder_buffer.h"
@@ skipping 42 matching lines @@
   }
 
   DecodeTimestamp operator+(const base::TimeDelta& rhs) const {
     return DecodeTimestamp(ts_ + rhs);
   }
 
   DecodeTimestamp operator-(const base::TimeDelta& rhs) const {
     return DecodeTimestamp(ts_ - rhs);
   }
 
-  int64 operator/(const base::TimeDelta& rhs) const {
-    return ts_ / rhs;
-  }
+  int64_t operator/(const base::TimeDelta& rhs) const { return ts_ / rhs; }
 
   static DecodeTimestamp FromSecondsD(double seconds) {
     return DecodeTimestamp(base::TimeDelta::FromSecondsD(seconds));
   }
 
-  static DecodeTimestamp FromMilliseconds(int64 milliseconds) {
+  static DecodeTimestamp FromMilliseconds(int64_t milliseconds) {
     return DecodeTimestamp(base::TimeDelta::FromMilliseconds(milliseconds));
   }
 
-  static DecodeTimestamp FromMicroseconds(int64 microseconds) {
+  static DecodeTimestamp FromMicroseconds(int64_t microseconds) {
     return DecodeTimestamp(base::TimeDelta::FromMicroseconds(microseconds));
   }
 
   // This method is used to explicitly call out when presentation timestamps
   // are being converted to a decode timestamp.
   static DecodeTimestamp FromPresentationTime(base::TimeDelta timestamp) {
     return DecodeTimestamp(timestamp);
   }
 
   double InSecondsF() const { return ts_.InSecondsF(); }
-  int64 InMilliseconds() const { return ts_.InMilliseconds(); }
-  int64 InMicroseconds() const { return ts_.InMicroseconds(); }
+  int64_t InMilliseconds() const { return ts_.InMilliseconds(); }
+  int64_t InMicroseconds() const { return ts_.InMicroseconds(); }
 
   // TODO(acolwell): Remove once all the hacks are gone. This method is called
   // by hacks where a decode time is being used as a presentation time.
   base::TimeDelta ToPresentationTime() const { return ts_; }
 
  private:
   explicit DecodeTimestamp(base::TimeDelta timestamp) : ts_(timestamp) { }
 
   base::TimeDelta ts_;
 };
 
 MEDIA_EXPORT extern inline DecodeTimestamp kNoDecodeTimestamp() {
   return DecodeTimestamp::FromPresentationTime(kNoTimestamp());
 }
 
 class MEDIA_EXPORT StreamParserBuffer : public DecoderBuffer {
  public:
   // Value used to signal an invalid decoder config ID.
   enum { kInvalidConfigId = -1 };
 
   typedef DemuxerStream::Type Type;
   typedef StreamParser::TrackId TrackId;
 
   static scoped_refptr<StreamParserBuffer> CreateEOSBuffer();
 
-  static scoped_refptr<StreamParserBuffer> CopyFrom(
-      const uint8* data, int data_size, bool is_key_frame, Type type,
-      TrackId track_id);
-  static scoped_refptr<StreamParserBuffer> CopyFrom(
-      const uint8* data, int data_size,
-      const uint8* side_data, int side_data_size, bool is_key_frame, Type type,
-      TrackId track_id);
+  static scoped_refptr<StreamParserBuffer> CopyFrom(const uint8_t* data,
+                                                    int data_size,
+                                                    bool is_key_frame,
+                                                    Type type,
+                                                    TrackId track_id);
+  static scoped_refptr<StreamParserBuffer> CopyFrom(const uint8_t* data,
+                                                    int data_size,
+                                                    const uint8_t* side_data,
+                                                    int side_data_size,
+                                                    bool is_key_frame,
+                                                    Type type,
+                                                    TrackId track_id);
 
   // Decode timestamp. If not explicitly set, or set to kNoTimestamp(), the
   // value will be taken from the normal timestamp.
   DecodeTimestamp GetDecodeTimestamp() const;
   void SetDecodeTimestamp(DecodeTimestamp timestamp);
 
   // Gets/sets the ID of the decoder config associated with this buffer.
   int GetConfigId() const;
   void SetConfigId(int config_id);
 
@@ skipping 42 matching lines @@
 
   void set_timestamp(base::TimeDelta timestamp) override;
 
   bool is_duration_estimated() const { return is_duration_estimated_; }
 
   void set_is_duration_estimated(bool is_estimated) {
     is_duration_estimated_ = is_estimated;
   }
 
  private:
-  StreamParserBuffer(const uint8* data, int data_size,
-                     const uint8* side_data, int side_data_size,
-                     bool is_key_frame, Type type,
+  StreamParserBuffer(const uint8_t* data,
+                     int data_size,
+                     const uint8_t* side_data,
+                     int side_data_size,
+                     bool is_key_frame,
+                     Type type,
                      TrackId track_id);
   ~StreamParserBuffer() override;
 
   DecodeTimestamp decode_timestamp_;
   int config_id_;
   Type type_;
   TrackId track_id_;
   BufferQueue splice_buffers_;
   scoped_refptr<StreamParserBuffer> preroll_buffer_;
   bool is_duration_estimated_;
 
   DISALLOW_COPY_AND_ASSIGN(StreamParserBuffer);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_STREAM_PARSER_BUFFER_H_