Switch to standard integer types in media/.

BUG=138542
TBR=dalecurtis@chromium.org

Review URL: https://codereview.chromium.org/1534273002 .

Cr-Commit-Position: refs/heads/master@{#366242}

29 files changed, 381 insertions, 326 deletions

diff --git a/media/formats/webm/cluster_builder.cc b/media/formats/webm/cluster_builder.cc
index 1a3b358..b28b03b 100644
--- a/media/formats/webm/cluster_builder.cc
+++ b/media/formats/webm/cluster_builder.cc
@@ -10,34 +10,34 @@
 
 namespace media {
 
-static const uint8 kClusterHeader[] = {
-  0x1F, 0x43, 0xB6, 0x75,  // CLUSTER ID
-  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // cluster(size = 0)
-  0xE7,  // Timecode ID
-  0x88,  // timecode(size=8)
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // timecode value
+static const uint8_t kClusterHeader[] = {
+    0x1F, 0x43, 0xB6, 0x75,                          // CLUSTER ID
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // cluster(size = 0)
+    0xE7,                                            // Timecode ID
+    0x88,                                            // timecode(size=8)
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // timecode value
 };
 
-static const uint8 kSimpleBlockHeader[] = {
-  0xA3,  // SimpleBlock ID
-  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // SimpleBlock(size = 0)
+static const uint8_t kSimpleBlockHeader[] = {
+    0xA3,                                            // SimpleBlock ID
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // SimpleBlock(size = 0)
 };
 
-static const uint8 kBlockGroupHeader[] = {
-  0xA0,  // BlockGroup ID
-  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // BlockGroup(size = 0)
-  0x9B,  // BlockDuration ID
-  0x88,  // BlockDuration(size = 8)
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // duration
-  0xA1,  // Block ID
-  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Block(size = 0)
+static const uint8_t kBlockGroupHeader[] = {
+    0xA0,                                            // BlockGroup ID
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // BlockGroup(size = 0)
+    0x9B,                                            // BlockDuration ID
+    0x88,                                            // BlockDuration(size = 8)
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // duration
+    0xA1,                                            // Block ID
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Block(size = 0)
 };
 
-static const uint8 kBlockGroupHeaderWithoutBlockDuration[] = {
-  0xA0,  // BlockGroup ID
-  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // BlockGroup(size = 0)
-  0xA1,  // Block ID
-  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Block(size = 0)
+static const uint8_t kBlockGroupHeaderWithoutBlockDuration[] = {
+    0xA0,                                            // BlockGroup ID
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // BlockGroup(size = 0)
+    0xA1,                                            // Block ID
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Block(size = 0)
 };
 
 enum {
@@ -54,34 +54,37 @@ enum {
   kInitialBufferSize = 32768,
 };
 
-Cluster::Cluster(scoped_ptr<uint8[]> data, int size)
+Cluster::Cluster(scoped_ptr<uint8_t[]> data, int size)
     : data_(data.Pass()), size_(size) {}
 Cluster::~Cluster() {}
 
 ClusterBuilder::ClusterBuilder() { Reset(); }
 ClusterBuilder::~ClusterBuilder() {}
 
-void ClusterBuilder::SetClusterTimecode(int64 cluster_timecode) {
+void ClusterBuilder::SetClusterTimecode(int64_t cluster_timecode) {
   DCHECK_EQ(cluster_timecode_, -1);
 
   cluster_timecode_ = cluster_timecode;
 
   // Write the timecode into the header.
-  uint8* buf = buffer_.get() + kClusterTimecodeOffset;
+  uint8_t* buf = buffer_.get() + kClusterTimecodeOffset;
   for (int i = 7; i >= 0; --i) {
     buf[i] = cluster_timecode & 0xff;
     cluster_timecode >>= 8;
   }
 }
 
-void ClusterBuilder::AddSimpleBlock(int track_num, int64 timecode, int flags,
-                                    const uint8* data, int size) {
+void ClusterBuilder::AddSimpleBlock(int track_num,
+                                    int64_t timecode,
+                                    int flags,
+                                    const uint8_t* data,
+                                    int size) {
   int block_size = size + 4;
   int bytes_needed = sizeof(kSimpleBlockHeader) + block_size;
   if (bytes_needed > (buffer_size_ - bytes_used_))
     ExtendBuffer(bytes_needed);
 
-  uint8* buf = buffer_.get() + bytes_used_;
+  uint8_t* buf = buffer_.get() + bytes_used_;
   int block_offset = bytes_used_;
   memcpy(buf, kSimpleBlockHeader, sizeof(kSimpleBlockHeader));
   UpdateUInt64(block_offset + kSimpleBlockSizeOffset, block_size);
@@ -92,24 +95,30 @@ void ClusterBuilder::AddSimpleBlock(int track_num, int64 timecode, int flags,
   bytes_used_ += bytes_needed;
 }
 
-void ClusterBuilder::AddBlockGroup(int track_num, int64 timecode, int duration,
-                                   int flags, const uint8* data, int size) {
+void ClusterBuilder::AddBlockGroup(int track_num,
+                                   int64_t timecode,
+                                   int duration,
+                                   int flags,
+                                   const uint8_t* data,
+                                   int size) {
   AddBlockGroupInternal(track_num, timecode, true, duration, flags, data, size);
 }
 
 void ClusterBuilder::AddBlockGroupWithoutBlockDuration(int track_num,
-                                                       int64 timecode,
+                                                       int64_t timecode,
                                                        int flags,
-                                                       const uint8* data,
+                                                       const uint8_t* data,
                                                        int size) {
   AddBlockGroupInternal(track_num, timecode, false, 0, flags, data, size);
 }
 
-
-void ClusterBuilder::AddBlockGroupInternal(int track_num, int64 timecode,
+void ClusterBuilder::AddBlockGroupInternal(int track_num,
+                                           int64_t timecode,
                                            bool include_block_duration,
-                                           int duration, int flags,
-                                           const uint8* data, int size) {
+                                           int duration,
+                                           int flags,
+                                           const uint8_t* data,
+                                           int size) {
   int block_size = size + 4;
   int bytes_needed = block_size;
   if (include_block_duration) {
@@ -123,7 +132,7 @@ void ClusterBuilder::AddBlockGroupInternal(int track_num, int64 timecode,
   if (bytes_needed > (buffer_size_ - bytes_used_))
     ExtendBuffer(bytes_needed);
 
-  uint8* buf = buffer_.get() + bytes_used_;
+  uint8_t* buf = buffer_.get() + bytes_used_;
   int block_group_offset = bytes_used_;
   if (include_block_duration) {
     memcpy(buf, kBlockGroupHeader, sizeof(kBlockGroupHeader));
@@ -150,8 +159,12 @@ void ClusterBuilder::AddBlockGroupInternal(int track_num, int64 timecode,
   bytes_used_ += bytes_needed;
 }
 
-void ClusterBuilder::WriteBlock(uint8* buf, int track_num, int64 timecode,
-                                int flags, const uint8* data, int size) {
+void ClusterBuilder::WriteBlock(uint8_t* buf,
+                                int track_num,
+                                int64_t timecode,
+                                int flags,
+                                const uint8_t* data,
+                                int size) {
   DCHECK_GE(track_num, 0);
   DCHECK_LE(track_num, 126);
   DCHECK_GE(flags, 0);
@@ -160,7 +173,7 @@ void ClusterBuilder::WriteBlock(uint8* buf, int track_num, int64 timecode,
   DCHECK_GT(size, 0);
   DCHECK_NE(cluster_timecode_, -1);
 
-  int64 timecode_delta = timecode - cluster_timecode_;
+  int64_t timecode_delta = timecode - cluster_timecode_;
   DCHECK_GE(timecode_delta, -32768);
   DCHECK_LE(timecode_delta, 32767);
 
@@ -193,7 +206,7 @@ scoped_ptr<Cluster> ClusterBuilder::FinishWithUnknownSize() {
 
 void ClusterBuilder::Reset() {
   buffer_size_ = kInitialBufferSize;
-  buffer_.reset(new uint8[buffer_size_]);
+  buffer_.reset(new uint8_t[buffer_size_]);
   memcpy(buffer_.get(), kClusterHeader, sizeof(kClusterHeader));
   bytes_used_ = sizeof(kClusterHeader);
   cluster_timecode_ = -1;
@@ -205,16 +218,16 @@ void ClusterBuilder::ExtendBuffer(int bytes_needed) {
   while ((new_buffer_size - bytes_used_) < bytes_needed)
     new_buffer_size *= 2;
 
-  scoped_ptr<uint8[]> new_buffer(new uint8[new_buffer_size]);
+  scoped_ptr<uint8_t[]> new_buffer(new uint8_t[new_buffer_size]);
 
   memcpy(new_buffer.get(), buffer_.get(), bytes_used_);
   buffer_.reset(new_buffer.release());
   buffer_size_ = new_buffer_size;
 }
 
-void ClusterBuilder::UpdateUInt64(int offset, int64 value) {
+void ClusterBuilder::UpdateUInt64(int offset, int64_t value) {
   DCHECK_LE(offset + 7, buffer_size_);
-  uint8* buf = buffer_.get() + offset;
+  uint8_t* buf = buffer_.get() + offset;
 
   // Fill the last 7 bytes of size field in big-endian order.
   for (int i = 7; i > 0; i--) {
diff --git a/media/formats/webm/cluster_builder.h b/media/formats/webm/cluster_builder.h
index f6f6001..6e32ccc 100644
--- a/media/formats/webm/cluster_builder.h
+++ b/media/formats/webm/cluster_builder.h
@@ -5,21 +5,20 @@
 #ifndef MEDIA_FORMATS_WEBM_CLUSTER_BUILDER_H_
 #define MEDIA_FORMATS_WEBM_CLUSTER_BUILDER_H_
 
-#include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 
 namespace media {
 
 class Cluster {
  public:
-  Cluster(scoped_ptr<uint8[]> data, int size);
+  Cluster(scoped_ptr<uint8_t[]> data, int size);
   ~Cluster();
 
-  const uint8* data() const { return data_.get(); }
+  const uint8_t* data() const { return data_.get(); }
   int size() const { return size_; }
 
  private:
-  scoped_ptr<uint8[]> data_;
+  scoped_ptr<uint8_t[]> data_;
   int size_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(Cluster);
@@ -30,31 +29,49 @@ class ClusterBuilder {
   ClusterBuilder();
   ~ClusterBuilder();
 
-  void SetClusterTimecode(int64 cluster_timecode);
-  void AddSimpleBlock(int track_num, int64 timecode, int flags,
-                      const uint8* data, int size);
-  void AddBlockGroup(int track_num, int64 timecode, int duration, int flags,
-                     const uint8* data, int size);
-  void AddBlockGroupWithoutBlockDuration(int track_num, int64 timecode,
-                     int flags, const uint8* data, int size);
+  void SetClusterTimecode(int64_t cluster_timecode);
+  void AddSimpleBlock(int track_num,
+                      int64_t timecode,
+                      int flags,
+                      const uint8_t* data,
+                      int size);
+  void AddBlockGroup(int track_num,
+                     int64_t timecode,
+                     int duration,
+                     int flags,
+                     const uint8_t* data,
+                     int size);
+  void AddBlockGroupWithoutBlockDuration(int track_num,
+                                         int64_t timecode,
+                                         int flags,
+                                         const uint8_t* data,
+                                         int size);
 
   scoped_ptr<Cluster> Finish();
   scoped_ptr<Cluster> FinishWithUnknownSize();
 
  private:
-  void AddBlockGroupInternal(int track_num, int64 timecode,
-                             bool include_block_duration, int duration,
-                             int flags, const uint8* data, int size);
+  void AddBlockGroupInternal(int track_num,
+                             int64_t timecode,
+                             bool include_block_duration,
+                             int duration,
+                             int flags,
+                             const uint8_t* data,
+                             int size);
   void Reset();
   void ExtendBuffer(int bytes_needed);
-  void UpdateUInt64(int offset, int64 value);
-  void WriteBlock(uint8* buf, int track_num, int64 timecode, int flags,
-                  const uint8* data, int size);
+  void UpdateUInt64(int offset, int64_t value);
+  void WriteBlock(uint8_t* buf,
+                  int track_num,
+                  int64_t timecode,
+                  int flags,
+                  const uint8_t* data,
+                  int size);
 
-  scoped_ptr<uint8[]> buffer_;
+  scoped_ptr<uint8_t[]> buffer_;
   int buffer_size_;
   int bytes_used_;
-  int64 cluster_timecode_;
+  int64_t cluster_timecode_;
 
   DISALLOW_COPY_AND_ASSIGN(ClusterBuilder);
 };
diff --git a/media/formats/webm/tracks_builder.cc b/media/formats/webm/tracks_builder.cc
index 927c2a4..6b2aaea 100644
--- a/media/formats/webm/tracks_builder.cc
+++ b/media/formats/webm/tracks_builder.cc
@@ -10,7 +10,7 @@
 namespace media {
 
 // Returns size of an integer, formatted using Matroska serialization.
-static int GetUIntMkvSize(uint64 value) {
+static int GetUIntMkvSize(uint64_t value) {
   if (value < 0x07FULL)
     return 1;
   if (value < 0x03FFFULL)
@@ -29,7 +29,7 @@ static int GetUIntMkvSize(uint64 value) {
 }
 
 // Returns the minimium size required to serialize an integer value.
-static int GetUIntSize(uint64 value) {
+static int GetUIntSize(uint64_t value) {
   if (value < 0x0100ULL)
     return 1;
   if (value < 0x010000ULL)
@@ -51,7 +51,7 @@ static int MasterElementSize(int element_id, int payload_size) {
   return GetUIntSize(element_id) + GetUIntMkvSize(payload_size) + payload_size;
 }
 
-static int UIntElementSize(int element_id, uint64 value) {
+static int UIntElementSize(int element_id, uint64_t value) {
   return GetUIntSize(element_id) + 1 + GetUIntSize(value);
 }
 
@@ -65,23 +65,26 @@ static int StringElementSize(int element_id, const std::string& value) {
         value.length();
 }
 
-static void SerializeInt(uint8** buf_ptr, int* buf_size_ptr,
-                         int64 value, int size) {
-  uint8*& buf = *buf_ptr;
+static void SerializeInt(uint8_t** buf_ptr,
+                         int* buf_size_ptr,
+                         int64_t value,
+                         int size) {
+  uint8_t*& buf = *buf_ptr;
   int& buf_size = *buf_size_ptr;
 
   for (int idx = 1; idx <= size; ++idx) {
-    *buf++ = static_cast<uint8>(value >> ((size - idx) * 8));
+    *buf++ = static_cast<uint8_t>(value >> ((size - idx) * 8));
     --buf_size;
   }
 }
 
-static void SerializeDouble(uint8** buf_ptr, int* buf_size_ptr,
+static void SerializeDouble(uint8_t** buf_ptr,
+                            int* buf_size_ptr,
                             double value) {
   // Use a union to convert |value| to native endian integer bit pattern.
   union {
     double src;
-    int64 dst;
+    int64_t dst;
   } tmp;
   tmp.src = value;
 
@@ -89,26 +92,28 @@ static void SerializeDouble(uint8** buf_ptr, int* buf_size_ptr,
   SerializeInt(buf_ptr, buf_size_ptr, tmp.dst, 8);
 }
 
-static void WriteElementId(uint8** buf, int* buf_size, int element_id) {
+static void WriteElementId(uint8_t** buf, int* buf_size, int element_id) {
   SerializeInt(buf, buf_size, element_id, GetUIntSize(element_id));
 }
 
-static void WriteUInt(uint8** buf, int* buf_size, uint64 value) {
+static void WriteUInt(uint8_t** buf, int* buf_size, uint64_t value) {
   const int size = GetUIntMkvSize(value);
   value |= (1ULL << (size * 7));  // Matroska formatting
   SerializeInt(buf, buf_size, value, size);
 }
 
-static void WriteMasterElement(uint8** buf, int* buf_size,
-                               int element_id, int payload_size) {
+static void WriteMasterElement(uint8_t** buf,
+                               int* buf_size,
+                               int element_id,
+                               int payload_size) {
   WriteElementId(buf, buf_size, element_id);
   WriteUInt(buf, buf_size, payload_size);
 }
 
-static void WriteUIntElement(uint8** buf,
+static void WriteUIntElement(uint8_t** buf,
                              int* buf_size,
                              int element_id,
-                             uint64 value) {
+                             uint64_t value) {
   WriteElementId(buf, buf_size, element_id);
 
   const int size = GetUIntSize(value);
@@ -117,21 +122,25 @@ static void WriteUIntElement(uint8** buf,
   SerializeInt(buf, buf_size, value, size);
 }
 
-static void WriteDoubleElement(uint8** buf, int* buf_size,
-                               int element_id, double value) {
+static void WriteDoubleElement(uint8_t** buf,
+                               int* buf_size,
+                               int element_id,
+                               double value) {
   WriteElementId(buf, buf_size, element_id);
   WriteUInt(buf, buf_size, 8);
   SerializeDouble(buf, buf_size, value);
 }
 
-static void WriteStringElement(uint8** buf_ptr, int* buf_size_ptr,
-                               int element_id, const std::string& value) {
-  uint8*& buf = *buf_ptr;
+static void WriteStringElement(uint8_t** buf_ptr,
+                               int* buf_size_ptr,
+                               int element_id,
+                               const std::string& value) {
+  uint8_t*& buf = *buf_ptr;
   int& buf_size = *buf_size_ptr;
 
   WriteElementId(&buf, &buf_size, element_id);
 
-  const uint64 size = value.length();
+  const uint64_t size = value.length();
   WriteUInt(&buf, &buf_size, size);
 
   memcpy(buf, value.data(), size);
@@ -146,7 +155,7 @@ TracksBuilder::TracksBuilder()
 TracksBuilder::~TracksBuilder() {}
 
 void TracksBuilder::AddVideoTrack(int track_num,
-                                  uint64 track_uid,
+                                  uint64_t track_uid,
                                   const std::string& codec_id,
                                   const std::string& name,
                                   const std::string& language,
@@ -159,7 +168,7 @@ void TracksBuilder::AddVideoTrack(int track_num,
 }
 
 void TracksBuilder::AddAudioTrack(int track_num,
-                                  uint64 track_uid,
+                                  uint64_t track_uid,
                                   const std::string& codec_id,
                                   const std::string& name,
                                   const std::string& language,
@@ -172,7 +181,7 @@ void TracksBuilder::AddAudioTrack(int track_num,
 }
 
 void TracksBuilder::AddTextTrack(int track_num,
-                                 uint64 track_uid,
+                                 uint64_t track_uid,
                                  const std::string& codec_id,
                                  const std::string& name,
                                  const std::string& language) {
@@ -180,9 +189,9 @@ void TracksBuilder::AddTextTrack(int track_num,
                    codec_id, name, language, -1, -1, -1, -1, -1);
 }
 
-std::vector<uint8> TracksBuilder::Finish() {
+std::vector<uint8_t> TracksBuilder::Finish() {
   // Allocate the storage
-  std::vector<uint8> buffer;
+  std::vector<uint8_t> buffer;
   buffer.resize(GetTracksSize());
 
   // Populate the storage with a tracks header
@@ -193,7 +202,7 @@ std::vector<uint8> TracksBuilder::Finish() {
 
 void TracksBuilder::AddTrackInternal(int track_num,
                                      int track_type,
-                                     uint64 track_uid,
+                                     uint64_t track_uid,
                                      const std::string& codec_id,
                                      const std::string& name,
                                      const std::string& language,
@@ -223,7 +232,7 @@ int TracksBuilder::GetTracksPayloadSize() const {
   return payload_size;
 }
 
-void TracksBuilder::WriteTracks(uint8* buf, int buf_size) const {
+void TracksBuilder::WriteTracks(uint8_t* buf, int buf_size) const {
   WriteMasterElement(&buf, &buf_size, kWebMIdTracks, GetTracksPayloadSize());
 
   for (TrackList::const_iterator itr = tracks_.begin();
@@ -234,7 +243,7 @@ void TracksBuilder::WriteTracks(uint8* buf, int buf_size) const {
 
 TracksBuilder::Track::Track(int track_num,
                             int track_type,
-                            uint64 track_uid,
+                            uint64_t track_uid,
                             const std::string& codec_id,
                             const std::string& name,
                             const std::string& language,
@@ -341,7 +350,7 @@ int TracksBuilder::Track::GetPayloadSize() const {
   return size;
 }
 
-void TracksBuilder::Track::Write(uint8** buf, int* buf_size) const {
+void TracksBuilder::Track::Write(uint8_t** buf, int* buf_size) const {
   WriteMasterElement(buf, buf_size, kWebMIdTrackEntry, GetPayloadSize());
 
   WriteUIntElement(buf, buf_size, kWebMIdTrackNumber, track_num_);
diff --git a/media/formats/webm/tracks_builder.h b/media/formats/webm/tracks_builder.h
index f7786fd..dc0283e 100644
--- a/media/formats/webm/tracks_builder.h
+++ b/media/formats/webm/tracks_builder.h
@@ -5,11 +5,13 @@
 #ifndef MEDIA_FORMATS_WEBM_TRACKS_BUILDER_H_
 #define MEDIA_FORMATS_WEBM_TRACKS_BUILDER_H_
 
+#include <stdint.h>
+
 #include <list>
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
+#include "base/macros.h"
 
 namespace media {
 
@@ -28,7 +30,7 @@ class TracksBuilder {
   // DefaultDuration. Similar applies to |audio_channels|,
   // |audio_sampling_frequency|, |video_pixel_width| and |video_pixel_height|.
   void AddVideoTrack(int track_num,
-                     uint64 track_uid,
+                     uint64_t track_uid,
                      const std::string& codec_id,
                      const std::string& name,
                      const std::string& language,
@@ -36,7 +38,7 @@ class TracksBuilder {
                      int video_pixel_width,
                      int video_pixel_height);
   void AddAudioTrack(int track_num,
-                     uint64 track_uid,
+                     uint64_t track_uid,
                      const std::string& codec_id,
                      const std::string& name,
                      const std::string& language,
@@ -44,17 +46,17 @@ class TracksBuilder {
                      int audio_channels,
                      double audio_sampling_frequency);
   void AddTextTrack(int track_num,
-                    uint64 track_uid,
+                    uint64_t track_uid,
                     const std::string& codec_id,
                     const std::string& name,
                     const std::string& language);
 
-  std::vector<uint8> Finish();
+  std::vector<uint8_t> Finish();
 
  private:
   void AddTrackInternal(int track_num,
                         int track_type,
-                        uint64 track_uid,
+                        uint64_t track_uid,
                         const std::string& codec_id,
                         const std::string& name,
                         const std::string& language,
@@ -65,13 +67,13 @@ class TracksBuilder {
                         double audio_sampling_frequency);
   int GetTracksSize() const;
   int GetTracksPayloadSize() const;
-  void WriteTracks(uint8* buffer, int buffer_size) const;
+  void WriteTracks(uint8_t* buffer, int buffer_size) const;
 
   class Track {
    public:
     Track(int track_num,
           int track_type,
-          uint64 track_uid,
+          uint64_t track_uid,
           const std::string& codec_id,
           const std::string& name,
           const std::string& language,
@@ -83,7 +85,8 @@ class TracksBuilder {
           bool allow_invalid_values);
 
     int GetSize() const;
-    void Write(uint8** buf, int* buf_size) const;
+    void Write(uint8_t** buf, int* buf_size) const;
+
    private:
     int GetPayloadSize() const;
     int GetVideoPayloadSize() const;
diff --git a/media/formats/webm/webm_audio_client.cc b/media/formats/webm/webm_audio_client.cc
index 995746a4..fb6a723a 100644
--- a/media/formats/webm/webm_audio_client.cc
+++ b/media/formats/webm/webm_audio_client.cc
@@ -25,8 +25,11 @@ void WebMAudioClient::Reset() {
 }
 
 bool WebMAudioClient::InitializeConfig(
-    const std::string& codec_id, const std::vector<uint8>& codec_private,
-    int64 seek_preroll, int64 codec_delay, bool is_encrypted,
+    const std::string& codec_id,
+    const std::vector<uint8_t>& codec_private,
+    int64_t seek_preroll,
+    int64_t codec_delay,
+    bool is_encrypted,
     AudioDecoderConfig* config) {
   DCHECK(config);
   SampleFormat sample_format = kSampleFormatPlanarF32;
@@ -88,7 +91,7 @@ bool WebMAudioClient::InitializeConfig(
   return config->IsValidConfig();
 }
 
-bool WebMAudioClient::OnUInt(int id, int64 val) {
+bool WebMAudioClient::OnUInt(int id, int64_t val) {
   if (id == kWebMIdChannels) {
     if (channels_ != -1) {
       MEDIA_LOG(ERROR, media_log_) << "Multiple values for id " << std::hex
diff --git a/media/formats/webm/webm_audio_client.h b/media/formats/webm/webm_audio_client.h
index 67f5f01..98f0eee 100644
--- a/media/formats/webm/webm_audio_client.h
+++ b/media/formats/webm/webm_audio_client.h
@@ -30,15 +30,15 @@ class WebMAudioClient : public WebMParserClient {
   // Returns false if there was unexpected values in the provided parameters or
   // audio track element fields.
   bool InitializeConfig(const std::string& codec_id,
-                        const std::vector<uint8>& codec_private,
-                        const int64 seek_preroll,
-                        const int64 codec_delay,
+                        const std::vector<uint8_t>& codec_private,
+                        const int64_t seek_preroll,
+                        const int64_t codec_delay,
                         bool is_encrypted,
                         AudioDecoderConfig* config);
 
  private:
   // WebMParserClient implementation.
-  bool OnUInt(int id, int64 val) override;
+  bool OnUInt(int id, int64_t val) override;
   bool OnFloat(int id, double val) override;
 
   scoped_refptr<MediaLog> media_log_;
diff --git a/media/formats/webm/webm_cluster_parser.cc b/media/formats/webm/webm_cluster_parser.cc
index ee49137..21420b74 100644
--- a/media/formats/webm/webm_cluster_parser.cc
+++ b/media/formats/webm/webm_cluster_parser.cc
@@ -32,13 +32,13 @@ enum {
 };
 
 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,
@@ -293,8 +293,8 @@ bool WebMClusterParser::OnListEnd(int id) {
   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_;
@@ -320,7 +320,7 @@ bool WebMClusterParser::ParseBlock(bool is_simple_block,
                                    const uint8_t* additional,
                                    int additional_size,
                                    int duration,
-                                   int64 discard_padding) {
+                                   int64_t discard_padding) {
   if (size < 4)
     return false;
 
@@ -371,7 +371,7 @@ bool WebMClusterParser::OnBinary(int id, const uint8_t* data, int 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
@@ -397,7 +397,7 @@ bool WebMClusterParser::OnBinary(int id, const uint8_t* data, int size) {
       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];
 
@@ -417,7 +417,7 @@ bool WebMClusterParser::OnBlock(bool is_simple_block,
                                 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.";
diff --git a/media/formats/webm/webm_cluster_parser.h b/media/formats/webm/webm_cluster_parser.h
index e2d5b98..bd02810 100644
--- a/media/formats/webm/webm_cluster_parser.h
+++ b/media/formats/webm/webm_cluster_parser.h
@@ -149,13 +149,13 @@ class MEDIA_EXPORT WebMClusterParser : public WebMParserClient {
   typedef std::map<int, Track> TextTrackMap;
 
  public:
-  WebMClusterParser(int64 timecode_scale,
+  WebMClusterParser(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,
@@ -209,7 +209,7 @@ class MEDIA_EXPORT WebMClusterParser : public WebMParserClient {
   // WebMParserClient methods.
   WebMParserClient* OnListStart(int id) override;
   bool OnListEnd(int id) override;
-  bool OnUInt(int id, int64 val) override;
+  bool OnUInt(int id, int64_t val) override;
   bool OnBinary(int id, const uint8_t* data, int size) override;
 
   bool ParseBlock(bool is_simple_block,
@@ -218,7 +218,7 @@ class MEDIA_EXPORT WebMClusterParser : public WebMParserClient {
                   const uint8_t* additional,
                   int additional_size,
                   int duration,
-                  int64 discard_padding);
+                  int64_t discard_padding);
   bool OnBlock(bool is_simple_block,
                int track_num,
                int timecode,
@@ -228,7 +228,7 @@ class MEDIA_EXPORT WebMClusterParser : public WebMParserClient {
                int size,
                const uint8_t* additional,
                int additional_size,
-               int64 discard_padding);
+               int64_t discard_padding);
 
   // Resets the Track objects associated with each text track.
   void ResetTextTracks();
@@ -273,28 +273,28 @@ class MEDIA_EXPORT WebMClusterParser : public WebMParserClient {
 
   double timecode_multiplier_;  // Multiplier used to convert timecodes into
                                 // microseconds.
-  std::set<int64> ignored_tracks_;
+  std::set<int64_t> ignored_tracks_;
   std::string audio_encryption_key_id_;
   std::string video_encryption_key_id_;
   const AudioCodec audio_codec_;
 
   WebMListParser parser_;
 
-  int64 last_block_timecode_ = -1;
+  int64_t last_block_timecode_ = -1;
   scoped_ptr<uint8_t[]> block_data_;
   int block_data_size_ = -1;
-  int64 block_duration_ = -1;
-  int64 block_add_id_ = -1;
+  int64_t block_duration_ = -1;
+  int64_t block_add_id_ = -1;
 
   scoped_ptr<uint8_t[]> block_additional_data_;
   // Must be 0 if |block_additional_data_| is null. Must be > 0 if
   // |block_additional_data_| is NOT null.
   int block_additional_data_size_ = 0;
 
-  int64 discard_padding_ = -1;
+  int64_t discard_padding_ = -1;
   bool discard_padding_set_ = false;
 
-  int64 cluster_timecode_ = -1;
+  int64_t cluster_timecode_ = -1;
   base::TimeDelta cluster_start_time_;
   bool cluster_ended_ = false;
 
diff --git a/media/formats/webm/webm_cluster_parser_unittest.cc b/media/formats/webm/webm_cluster_parser_unittest.cc
index 7581bbf..1605dfe 100644
--- a/media/formats/webm/webm_cluster_parser_unittest.cc
+++ b/media/formats/webm/webm_cluster_parser_unittest.cc
@@ -319,7 +319,7 @@ class WebMClusterParserTest : public testing::Test {
       base::TimeDelta audio_default_duration,
       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) {
@@ -333,7 +333,7 @@ class WebMClusterParserTest : public testing::Test {
   // Create a default version of the parser for test.
   WebMClusterParser* CreateDefaultParser() {
     return CreateParserHelper(kNoTimestamp(), kNoTimestamp(), TextTracks(),
-                              std::set<int64>(), std::string(), std::string(),
+                              std::set<int64_t>(), std::string(), std::string(),
                               kUnknownAudioCodec);
   }
 
@@ -344,13 +344,13 @@ class WebMClusterParserTest : public testing::Test {
       base::TimeDelta video_default_duration,
       const WebMTracksParser::TextTracks& text_tracks = TextTracks()) {
     return CreateParserHelper(audio_default_duration, video_default_duration,
-                              text_tracks, std::set<int64>(), std::string(),
+                              text_tracks, std::set<int64_t>(), std::string(),
                               std::string(), kUnknownAudioCodec);
   }
 
   // Create a parser for test with custom ignored tracks.
   WebMClusterParser* CreateParserWithIgnoredTracks(
-      std::set<int64>& ignored_tracks) {
+      std::set<int64_t>& ignored_tracks) {
     return CreateParserHelper(kNoTimestamp(), kNoTimestamp(), TextTracks(),
                               ignored_tracks, std::string(), std::string(),
                               kUnknownAudioCodec);
@@ -362,7 +362,7 @@ class WebMClusterParserTest : public testing::Test {
       const std::string& video_encryption_key_id,
       const AudioCodec audio_codec) {
     return CreateParserHelper(kNoTimestamp(), kNoTimestamp(), TextTracks(),
-                              std::set<int64>(), audio_encryption_key_id,
+                              std::set<int64_t>(), audio_encryption_key_id,
                               video_encryption_key_id, audio_codec);
   }
 
@@ -579,7 +579,7 @@ TEST_F(WebMClusterParserTest, ParseSimpleBlockAndBlockGroupMixture) {
 }
 
 TEST_F(WebMClusterParserTest, IgnoredTracks) {
-  std::set<int64> ignored_tracks;
+  std::set<int64_t> ignored_tracks;
   ignored_tracks.insert(kTextTrackNum);
 
   parser_.reset(CreateParserWithIgnoredTracks(ignored_tracks));
diff --git a/media/formats/webm/webm_constants.h b/media/formats/webm/webm_constants.h
index 8a0b8a7..711b40f 100644
--- a/media/formats/webm/webm_constants.h
+++ b/media/formats/webm/webm_constants.h
@@ -5,7 +5,8 @@
 #ifndef MEDIA_FORMATS_WEBM_WEBM_CONSTANTS_H_
 #define MEDIA_FORMATS_WEBM_WEBM_CONSTANTS_H_
 
-#include "base/basictypes.h"
+#include <stdint.h>
+
 #include "media/base/media_export.h"
 
 namespace media {
@@ -200,14 +201,14 @@ const int kWebMIdVideo = 0xE0;
 const int kWebMIdVoid = 0xEC;
 const int kWebMIdWritingApp = 0x5741;
 
-const int64 kWebMReservedId = 0x1FFFFFFF;
-const int64 kWebMUnknownSize = 0x00FFFFFFFFFFFFFFLL;
+const int64_t kWebMReservedId = 0x1FFFFFFF;
+const int64_t kWebMUnknownSize = 0x00FFFFFFFFFFFFFFLL;
 
-const uint8 kWebMFlagKeyframe = 0x80;
+const uint8_t kWebMFlagKeyframe = 0x80;
 
 // Current encrypted WebM request for comments specification is here
 // http://wiki.webmproject.org/encryption/webm-encryption-rfc
-const uint8 kWebMFlagEncryptedFrame = 0x1;
+const uint8_t kWebMFlagEncryptedFrame = 0x1;
 const int kWebMIvSize = 8;
 const int kWebMSignalByteSize = 1;
 
diff --git a/media/formats/webm/webm_content_encodings.cc b/media/formats/webm/webm_content_encodings.cc
index 157c6ac..440dcce 100644
--- a/media/formats/webm/webm_content_encodings.cc
+++ b/media/formats/webm/webm_content_encodings.cc
@@ -17,7 +17,7 @@ ContentEncoding::ContentEncoding()
 
 ContentEncoding::~ContentEncoding() {}
 
-void ContentEncoding::SetEncryptionKeyId(const uint8* encryption_key_id,
+void ContentEncoding::SetEncryptionKeyId(const uint8_t* encryption_key_id,
                                          int size) {
   DCHECK(encryption_key_id);
   DCHECK_GT(size, 0);
diff --git a/media/formats/webm/webm_content_encodings.h b/media/formats/webm/webm_content_encodings.h
index 5890ecf..1cc68a4 100644
--- a/media/formats/webm/webm_content_encodings.h
+++ b/media/formats/webm/webm_content_encodings.h
@@ -7,7 +7,6 @@
 
 #include <string>
 
-#include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "media/base/media_export.h"
 
@@ -52,8 +51,8 @@ class MEDIA_EXPORT ContentEncoding {
   ContentEncoding();
   ~ContentEncoding();
 
-  int64 order() const { return order_; }
-  void set_order(int64 order) { order_ = order; }
+  int64_t order() const { return order_; }
+  void set_order(int64_t order) { order_ = order; }
 
   Scope scope() const { return scope_; }
   void set_scope(Scope scope) { scope_ = scope; }
@@ -67,13 +66,13 @@ class MEDIA_EXPORT ContentEncoding {
   }
 
   const std::string& encryption_key_id() const { return encryption_key_id_; }
-  void SetEncryptionKeyId(const uint8* encryption_key_id, int size);
+  void SetEncryptionKeyId(const uint8_t* encryption_key_id, int size);
 
   CipherMode cipher_mode() const { return cipher_mode_; }
   void set_cipher_mode(CipherMode mode) { cipher_mode_ = mode; }
 
  private:
-  int64 order_;
+  int64_t order_;
   Scope scope_;
   Type type_;
   EncryptionAlgo encryption_algo_;
diff --git a/media/formats/webm/webm_content_encodings_client.cc b/media/formats/webm/webm_content_encodings_client.cc
index a9783dd..eb1b590 100644
--- a/media/formats/webm/webm_content_encodings_client.cc
+++ b/media/formats/webm/webm_content_encodings_client.cc
@@ -142,7 +142,7 @@ bool WebMContentEncodingsClient::OnListEnd(int id) {
 
 // Multiple occurrence restriction and range are checked in this function.
 // Mandatory occurrence restriction is checked in OnListEnd.
-bool WebMContentEncodingsClient::OnUInt(int id, int64 val) {
+bool WebMContentEncodingsClient::OnUInt(int id, int64_t val) {
   DCHECK(cur_content_encoding_.get());
 
   if (id == kWebMIdContentEncodingOrder) {
@@ -152,7 +152,7 @@ bool WebMContentEncodingsClient::OnUInt(int id, int64 val) {
       return false;
     }
 
-    if (val != static_cast<int64>(content_encodings_.size())) {
+    if (val != static_cast<int64_t>(content_encodings_.size())) {
       // According to the spec, encoding order starts with 0 and counts upwards.
       MEDIA_LOG(ERROR, media_log_) << "Unexpected ContentEncodingOrder.";
       return false;
@@ -252,7 +252,9 @@ bool WebMContentEncodingsClient::OnUInt(int id, int64 val) {
 
 // Multiple occurrence restriction is checked in this function.  Mandatory
 // restriction is checked in OnListEnd.
-bool WebMContentEncodingsClient::OnBinary(int id, const uint8* data, int size) {
+bool WebMContentEncodingsClient::OnBinary(int id,
+                                          const uint8_t* data,
+                                          int size) {
   DCHECK(cur_content_encoding_.get());
   DCHECK(data);
   DCHECK_GT(size, 0);
diff --git a/media/formats/webm/webm_content_encodings_client.h b/media/formats/webm/webm_content_encodings_client.h
index 85f7bf3..1144567 100644
--- a/media/formats/webm/webm_content_encodings_client.h
+++ b/media/formats/webm/webm_content_encodings_client.h
@@ -30,8 +30,8 @@ class MEDIA_EXPORT WebMContentEncodingsClient : public WebMParserClient {
   // WebMParserClient methods
   WebMParserClient* OnListStart(int id) override;
   bool OnListEnd(int id) override;
-  bool OnUInt(int id, int64 val) override;
-  bool OnBinary(int id, const uint8* data, int size) override;
+  bool OnUInt(int id, int64_t val) override;
+  bool OnBinary(int id, const uint8_t* data, int size) override;
 
  private:
   scoped_refptr<MediaLog> media_log_;
diff --git a/media/formats/webm/webm_content_encodings_client_unittest.cc b/media/formats/webm/webm_content_encodings_client_unittest.cc
index d31ad27..657e2c4 100644
--- a/media/formats/webm/webm_content_encodings_client_unittest.cc
+++ b/media/formats/webm/webm_content_encodings_client_unittest.cc
@@ -53,7 +53,7 @@ class WebMContentEncodingsClientTest : public testing::Test {
         client_(media_log_),
         parser_(kWebMIdContentEncodings, &client_) {}
 
-  void ParseAndExpectToFail(const uint8* buf, int size) {
+  void ParseAndExpectToFail(const uint8_t* buf, int size) {
     int result = parser_.Parse(buf, size);
     EXPECT_EQ(-1, result);
   }
@@ -65,8 +65,8 @@ class WebMContentEncodingsClientTest : public testing::Test {
 };
 
 TEST_F(WebMContentEncodingsClientTest, EmptyContentEncodings) {
-  const uint8 kContentEncodings[] = {
-    0x6D, 0x80, 0x80,  // ContentEncodings (size = 0)
+  const uint8_t kContentEncodings[] = {
+      0x6D, 0x80, 0x80,  // ContentEncodings (size = 0)
   };
   int size = sizeof(kContentEncodings);
   EXPECT_MEDIA_LOG(MissingContentEncoding());
@@ -74,25 +74,25 @@ TEST_F(WebMContentEncodingsClientTest, EmptyContentEncodings) {
 }
 
 TEST_F(WebMContentEncodingsClientTest, EmptyContentEncoding) {
-  const uint8 kContentEncodings[] = {
-    0x6D, 0x80, 0x83,  // ContentEncodings (size = 3)
-    0x63, 0x40, 0x80,  //   ContentEncoding (size = 0)
+  const uint8_t kContentEncodings[] = {
+      0x6D, 0x80, 0x83,  // ContentEncodings (size = 3)
+      0x63, 0x40, 0x80,  //   ContentEncoding (size = 0)
   };
   int size = sizeof(kContentEncodings);
   ParseAndExpectToFail(kContentEncodings, size);
 }
 
 TEST_F(WebMContentEncodingsClientTest, SingleContentEncoding) {
-  const uint8 kContentEncodings[] = {
-    0x6D, 0x80, 0xA1,        // ContentEncodings (size = 33)
-    0x62, 0x40, 0x9e,        //   ContentEncoding (size = 30)
-    0x50, 0x31, 0x81, 0x00,  //     ContentEncodingOrder (size = 1)
-    0x50, 0x32, 0x81, 0x01,  //     ContentEncodingScope (size = 1)
-    0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
-    0x50, 0x35, 0x8F,        //     ContentEncryption (size = 15)
-    0x47, 0xE1, 0x81, 0x05,  //       ContentEncAlgo (size = 1)
-    0x47, 0xE2, 0x88,        //       ContentEncKeyID (size = 8)
-    0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
+  const uint8_t kContentEncodings[] = {
+      0x6D, 0x80, 0xA1,        // ContentEncodings (size = 33)
+      0x62, 0x40, 0x9e,        //   ContentEncoding (size = 30)
+      0x50, 0x31, 0x81, 0x00,  //     ContentEncodingOrder (size = 1)
+      0x50, 0x32, 0x81, 0x01,  //     ContentEncodingScope (size = 1)
+      0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
+      0x50, 0x35, 0x8F,        //     ContentEncryption (size = 15)
+      0x47, 0xE1, 0x81, 0x05,  //       ContentEncAlgo (size = 1)
+      0x47, 0xE2, 0x88,        //       ContentEncKeyID (size = 8)
+      0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
   };
   int size = sizeof(kContentEncodings);
 
@@ -112,24 +112,24 @@ TEST_F(WebMContentEncodingsClientTest, SingleContentEncoding) {
 }
 
 TEST_F(WebMContentEncodingsClientTest, MultipleContentEncoding) {
-  const uint8 kContentEncodings[] = {
-    0x6D, 0x80, 0xC2,        // ContentEncodings (size = 66)
-    0x62, 0x40, 0x9e,        //   ContentEncoding (size = 30)
-    0x50, 0x31, 0x81, 0x00,  //     ContentEncodingOrder (size = 1)
-    0x50, 0x32, 0x81, 0x03,  //     ContentEncodingScope (size = 1)
-    0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
-    0x50, 0x35, 0x8F,        //     ContentEncryption (size = 15)
-    0x47, 0xE1, 0x81, 0x05,  //       ContentEncAlgo (size = 1)
-    0x47, 0xE2, 0x88,        //       ContentEncKeyID (size = 8)
-    0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
-    0x62, 0x40, 0x9e,        //   ContentEncoding (size = 30)
-    0x50, 0x31, 0x81, 0x01,  //     ContentEncodingOrder (size = 1)
-    0x50, 0x32, 0x81, 0x03,  //     ContentEncodingScope (size = 1)
-    0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
-    0x50, 0x35, 0x8F,        //     ContentEncryption (size = 15)
-    0x47, 0xE1, 0x81, 0x01,  //       ContentEncAlgo (size = 1)
-    0x47, 0xE2, 0x88,        //       ContentEncKeyID (size = 8)
-    0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
+  const uint8_t kContentEncodings[] = {
+      0x6D, 0x80, 0xC2,        // ContentEncodings (size = 66)
+      0x62, 0x40, 0x9e,        //   ContentEncoding (size = 30)
+      0x50, 0x31, 0x81, 0x00,  //     ContentEncodingOrder (size = 1)
+      0x50, 0x32, 0x81, 0x03,  //     ContentEncodingScope (size = 1)
+      0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
+      0x50, 0x35, 0x8F,        //     ContentEncryption (size = 15)
+      0x47, 0xE1, 0x81, 0x05,  //       ContentEncAlgo (size = 1)
+      0x47, 0xE2, 0x88,        //       ContentEncKeyID (size = 8)
+      0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
+      0x62, 0x40, 0x9e,        //   ContentEncoding (size = 30)
+      0x50, 0x31, 0x81, 0x01,  //     ContentEncodingOrder (size = 1)
+      0x50, 0x32, 0x81, 0x03,  //     ContentEncodingScope (size = 1)
+      0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
+      0x50, 0x35, 0x8F,        //     ContentEncryption (size = 15)
+      0x47, 0xE1, 0x81, 0x01,  //       ContentEncAlgo (size = 1)
+      0x47, 0xE2, 0x88,        //       ContentEncKeyID (size = 8)
+      0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
   };
   int size = sizeof(kContentEncodings);
 
@@ -152,14 +152,14 @@ TEST_F(WebMContentEncodingsClientTest, MultipleContentEncoding) {
 }
 
 TEST_F(WebMContentEncodingsClientTest, DefaultValues) {
-  const uint8 kContentEncodings[] = {
-    0x6D, 0x80, 0x8A,        // ContentEncodings (size = 10)
-    0x62, 0x40, 0x87,        //   ContentEncoding (size = 7)
-                             //     ContentEncodingOrder missing
-                             //     ContentEncodingScope missing
-    0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
-    0x50, 0x35, 0x80,        //     ContentEncryption (size = 0)
-                             //     ContentEncAlgo missing
+  const uint8_t kContentEncodings[] = {
+      0x6D, 0x80, 0x8A,        // ContentEncodings (size = 10)
+      0x62, 0x40, 0x87,        //   ContentEncoding (size = 7)
+                               //     ContentEncodingOrder missing
+                               //     ContentEncodingScope missing
+      0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
+      0x50, 0x35, 0x80,        //     ContentEncryption (size = 0)
+                               //     ContentEncAlgo missing
   };
   int size = sizeof(kContentEncodings);
 
@@ -179,16 +179,16 @@ TEST_F(WebMContentEncodingsClientTest, DefaultValues) {
 }
 
 TEST_F(WebMContentEncodingsClientTest, ContentEncodingsClientReuse) {
-  const uint8 kContentEncodings[] = {
-    0x6D, 0x80, 0xA1,        // ContentEncodings (size = 33)
-    0x62, 0x40, 0x9e,        //   ContentEncoding (size = 30)
-    0x50, 0x31, 0x81, 0x00,  //     ContentEncodingOrder (size = 1)
-    0x50, 0x32, 0x81, 0x01,  //     ContentEncodingScope (size = 1)
-    0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
-    0x50, 0x35, 0x8F,        //     ContentEncryption (size = 15)
-    0x47, 0xE1, 0x81, 0x05,  //       ContentEncAlgo (size = 1)
-    0x47, 0xE2, 0x88,        //       ContentEncKeyID (size = 8)
-    0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
+  const uint8_t kContentEncodings[] = {
+      0x6D, 0x80, 0xA1,        // ContentEncodings (size = 33)
+      0x62, 0x40, 0x9e,        //   ContentEncoding (size = 30)
+      0x50, 0x31, 0x81, 0x00,  //     ContentEncodingOrder (size = 1)
+      0x50, 0x32, 0x81, 0x01,  //     ContentEncodingScope (size = 1)
+      0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
+      0x50, 0x35, 0x8F,        //     ContentEncryption (size = 15)
+      0x47, 0xE1, 0x81, 0x05,  //       ContentEncAlgo (size = 1)
+      0x47, 0xE2, 0x88,        //       ContentEncKeyID (size = 8)
+      0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
   };
   int size = sizeof(kContentEncodings);
 
@@ -214,12 +214,12 @@ TEST_F(WebMContentEncodingsClientTest, ContentEncodingsClientReuse) {
 }
 
 TEST_F(WebMContentEncodingsClientTest, InvalidContentEncodingOrder) {
-  const uint8 kContentEncodings[] = {
-    0x6D, 0x80, 0x8E,        // ContentEncodings (size = 14)
-    0x62, 0x40, 0x8B,        //   ContentEncoding (size = 11)
-    0x50, 0x31, 0x81, 0xEE,  //     ContentEncodingOrder (size = 1), invalid
-    0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
-    0x50, 0x35, 0x80,        //     ContentEncryption (size = 0)
+  const uint8_t kContentEncodings[] = {
+      0x6D, 0x80, 0x8E,        // ContentEncodings (size = 14)
+      0x62, 0x40, 0x8B,        //   ContentEncoding (size = 11)
+      0x50, 0x31, 0x81, 0xEE,  //     ContentEncodingOrder (size = 1), invalid
+      0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
+      0x50, 0x35, 0x80,        //     ContentEncryption (size = 0)
   };
   int size = sizeof(kContentEncodings);
   EXPECT_MEDIA_LOG(UnexpectedContentEncodingOrder());
@@ -227,12 +227,12 @@ TEST_F(WebMContentEncodingsClientTest, InvalidContentEncodingOrder) {
 }
 
 TEST_F(WebMContentEncodingsClientTest, InvalidContentEncodingScope) {
-  const uint8 kContentEncodings[] = {
-    0x6D, 0x80, 0x8E,        // ContentEncodings (size = 14)
-    0x62, 0x40, 0x8B,        //   ContentEncoding (size = 11)
-    0x50, 0x32, 0x81, 0xEE,  //     ContentEncodingScope (size = 1), invalid
-    0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
-    0x50, 0x35, 0x80,        //     ContentEncryption (size = 0)
+  const uint8_t kContentEncodings[] = {
+      0x6D, 0x80, 0x8E,        // ContentEncodings (size = 14)
+      0x62, 0x40, 0x8B,        //   ContentEncoding (size = 11)
+      0x50, 0x32, 0x81, 0xEE,  //     ContentEncodingScope (size = 1), invalid
+      0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
+      0x50, 0x35, 0x80,        //     ContentEncryption (size = 0)
   };
   int size = sizeof(kContentEncodings);
   EXPECT_MEDIA_LOG(UnexpectedContentEncodingScope());
@@ -240,11 +240,11 @@ TEST_F(WebMContentEncodingsClientTest, InvalidContentEncodingScope) {
 }
 
 TEST_F(WebMContentEncodingsClientTest, InvalidContentEncodingType) {
-  const uint8 kContentEncodings[] = {
-    0x6D, 0x80, 0x8E,        // ContentEncodings (size = 14)
-    0x62, 0x40, 0x8B,        //   ContentEncoding (size = 11)
-    0x50, 0x33, 0x81, 0x00,  //     ContentEncodingType (size = 1), invalid
-    0x50, 0x35, 0x80,        //     ContentEncryption (size = 0)
+  const uint8_t kContentEncodings[] = {
+      0x6D, 0x80, 0x8E,        // ContentEncodings (size = 14)
+      0x62, 0x40, 0x8B,        //   ContentEncoding (size = 11)
+      0x50, 0x33, 0x81, 0x00,  //     ContentEncodingType (size = 1), invalid
+      0x50, 0x35, 0x80,        //     ContentEncryption (size = 0)
   };
   int size = sizeof(kContentEncodings);
   EXPECT_MEDIA_LOG(ContentCompressionNotSupported());
@@ -253,11 +253,11 @@ TEST_F(WebMContentEncodingsClientTest, InvalidContentEncodingType) {
 
 // ContentEncodingType is encryption but no ContentEncryption present.
 TEST_F(WebMContentEncodingsClientTest, MissingContentEncryption) {
-  const uint8 kContentEncodings[] = {
-    0x6D, 0x80, 0x87,        // ContentEncodings (size = 7)
-    0x62, 0x40, 0x84,        //   ContentEncoding (size = 4)
-    0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
-                             //     ContentEncryption missing
+  const uint8_t kContentEncodings[] = {
+      0x6D, 0x80, 0x87,        // ContentEncodings (size = 7)
+      0x62, 0x40, 0x84,        //   ContentEncoding (size = 4)
+      0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
+                               //     ContentEncryption missing
   };
   int size = sizeof(kContentEncodings);
   EXPECT_MEDIA_LOG(MissingContentEncryption());
@@ -265,14 +265,14 @@ TEST_F(WebMContentEncodingsClientTest, MissingContentEncryption) {
 }
 
 TEST_F(WebMContentEncodingsClientTest, InvalidContentEncAlgo) {
-  const uint8 kContentEncodings[] = {
-    0x6D, 0x80, 0x99,        // ContentEncodings (size = 25)
-    0x62, 0x40, 0x96,        //   ContentEncoding (size = 22)
-    0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
-    0x50, 0x35, 0x8F,        //     ContentEncryption (size = 15)
-    0x47, 0xE1, 0x81, 0xEE,  //       ContentEncAlgo (size = 1), invalid
-    0x47, 0xE2, 0x88,        //       ContentEncKeyID (size = 8)
-    0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
+  const uint8_t kContentEncodings[] = {
+      0x6D, 0x80, 0x99,        // ContentEncodings (size = 25)
+      0x62, 0x40, 0x96,        //   ContentEncoding (size = 22)
+      0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
+      0x50, 0x35, 0x8F,        //     ContentEncryption (size = 15)
+      0x47, 0xE1, 0x81, 0xEE,  //       ContentEncAlgo (size = 1), invalid
+      0x47, 0xE2, 0x88,        //       ContentEncKeyID (size = 8)
+      0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
   };
   int size = sizeof(kContentEncodings);
   EXPECT_MEDIA_LOG(UnexpectedContentEncAlgo(0xEE));
diff --git a/media/formats/webm/webm_crypto_helpers.cc b/media/formats/webm/webm_crypto_helpers.cc
index bd473bc..11e71b1 100644
--- a/media/formats/webm/webm_crypto_helpers.cc
+++ b/media/formats/webm/webm_crypto_helpers.cc
@@ -16,7 +16,7 @@ namespace {
 // CTR IV appended with a CTR block counter. |iv| is an 8 byte CTR IV.
 // |iv_size| is the size of |iv| in btyes. Returns a string of
 // kDecryptionKeySize bytes.
-std::string GenerateWebMCounterBlock(const uint8* iv, int iv_size) {
+std::string GenerateWebMCounterBlock(const uint8_t* iv, int iv_size) {
   std::string counter_block(reinterpret_cast<const char*>(iv), iv_size);
   counter_block.append(DecryptConfig::kDecryptionKeySize - iv_size, 0);
   return counter_block;
@@ -24,8 +24,10 @@ std::string GenerateWebMCounterBlock(const uint8* iv, int iv_size) {
 
 }  // namespace anonymous
 
-bool WebMCreateDecryptConfig(const uint8* data, int data_size,
-                             const uint8* key_id, int key_id_size,
+bool WebMCreateDecryptConfig(const uint8_t* data,
+                             int data_size,
+                             const uint8_t* key_id,
+                             int key_id_size,
                              scoped_ptr<DecryptConfig>* decrypt_config,
                              int* data_offset) {
   if (data_size < kWebMSignalByteSize) {
@@ -33,7 +35,7 @@ bool WebMCreateDecryptConfig(const uint8* data, int data_size,
     return false;
   }
 
-  uint8 signal_byte = data[0];
+  uint8_t signal_byte = data[0];
   int frame_offset = sizeof(signal_byte);
 
   // Setting the DecryptConfig object of the buffer while leaving the
diff --git a/media/formats/webm/webm_crypto_helpers.h b/media/formats/webm/webm_crypto_helpers.h
index 41ad5b1..d386302 100644
--- a/media/formats/webm/webm_crypto_helpers.h
+++ b/media/formats/webm/webm_crypto_helpers.h
@@ -5,7 +5,6 @@
 #ifndef MEDIA_FORMATS_WEBM_WEBM_CRYPTO_HELPERS_H_
 #define MEDIA_FORMATS_WEBM_WEBM_CRYPTO_HELPERS_H_
 
-#include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "media/base/decoder_buffer.h"
 
@@ -18,8 +17,10 @@ namespace media {
 // false otherwise, in which case |decrypt_config| and |data_offset| will not be
 // changed. Current encrypted WebM request for comments specification is here
 // http://wiki.webmproject.org/encryption/webm-encryption-rfc
-bool WebMCreateDecryptConfig(const uint8* data, int data_size,
-                             const uint8* key_id, int key_id_size,
+bool WebMCreateDecryptConfig(const uint8_t* data,
+                             int data_size,
+                             const uint8_t* key_id,
+                             int key_id_size,
                              scoped_ptr<DecryptConfig>* decrypt_config,
                              int* data_offset);
 
diff --git a/media/formats/webm/webm_info_parser.cc b/media/formats/webm/webm_info_parser.cc
index 6309c21..be6d708 100644
--- a/media/formats/webm/webm_info_parser.cc
+++ b/media/formats/webm/webm_info_parser.cc
@@ -20,7 +20,7 @@ WebMInfoParser::WebMInfoParser()
 
 WebMInfoParser::~WebMInfoParser() {}
 
-int WebMInfoParser::Parse(const uint8* buf, int size) {
+int WebMInfoParser::Parse(const uint8_t* buf, int size) {
   timecode_scale_ = -1;
   duration_ = -1;
 
@@ -45,7 +45,7 @@ bool WebMInfoParser::OnListEnd(int id) {
   return true;
 }
 
-bool WebMInfoParser::OnUInt(int id, int64 val) {
+bool WebMInfoParser::OnUInt(int id, int64_t val) {
   if (id != kWebMIdTimecodeScale)
     return true;
 
@@ -73,12 +73,12 @@ bool WebMInfoParser::OnFloat(int id, double val) {
   return true;
 }
 
-bool WebMInfoParser::OnBinary(int id, const uint8* data, int size) {
+bool WebMInfoParser::OnBinary(int id, const uint8_t* data, int size) {
   if (id == kWebMIdDateUTC) {
     if (size != 8)
       return false;
 
-    int64 date_in_nanoseconds = 0;
+    int64_t date_in_nanoseconds = 0;
     for (int i = 0; i < size; ++i)
       date_in_nanoseconds = (date_in_nanoseconds << 8) | data[i];
 
diff --git a/media/formats/webm/webm_info_parser.h b/media/formats/webm/webm_info_parser.h
index 44ef6b2..bec5cd2 100644
--- a/media/formats/webm/webm_info_parser.h
+++ b/media/formats/webm/webm_info_parser.h
@@ -23,9 +23,9 @@ class MEDIA_EXPORT WebMInfoParser : public WebMParserClient {
   // Returns -1 if the parse fails.
   // Returns 0 if more data is needed.
   // Returns the number of bytes parsed on success.
-  int Parse(const uint8* buf, int size);
+  int Parse(const uint8_t* buf, int size);
 
-  int64 timecode_scale() const { return timecode_scale_; }
+  int64_t timecode_scale() const { return timecode_scale_; }
   double duration() const { return duration_; }
   base::Time date_utc() const { return date_utc_; }
 
@@ -33,12 +33,12 @@ class MEDIA_EXPORT WebMInfoParser : public WebMParserClient {
   // WebMParserClient methods
   WebMParserClient* OnListStart(int id) override;
   bool OnListEnd(int id) override;
-  bool OnUInt(int id, int64 val) override;
+  bool OnUInt(int id, int64_t val) override;
   bool OnFloat(int id, double val) override;
-  bool OnBinary(int id, const uint8* data, int size) override;
+  bool OnBinary(int id, const uint8_t* data, int size) override;
   bool OnString(int id, const std::string& str) override;
 
-  int64 timecode_scale_;
+  int64_t timecode_scale_;
   double duration_;
   base::Time date_utc_;
 
diff --git a/media/formats/webm/webm_stream_parser.cc b/media/formats/webm/webm_stream_parser.cc
index b978b96..6695e2e 100644
--- a/media/formats/webm/webm_stream_parser.cc
+++ b/media/formats/webm/webm_stream_parser.cc
@@ -67,7 +67,7 @@ void WebMStreamParser::Flush() {
   }
 }
 
-bool WebMStreamParser::Parse(const uint8* buf, int size) {
+bool WebMStreamParser::Parse(const uint8_t* buf, int size) {
   DCHECK_NE(state_, kWaitingForInit);
 
   if (state_ == kError)
@@ -77,7 +77,7 @@ bool WebMStreamParser::Parse(const uint8* buf, int size) {
 
   int result = 0;
   int bytes_parsed = 0;
-  const uint8* cur = NULL;
+  const uint8_t* cur = NULL;
   int cur_size = 0;
 
   byte_queue_.Peek(&cur, &cur_size);
@@ -120,17 +120,17 @@ void WebMStreamParser::ChangeState(State new_state) {
   state_ = new_state;
 }
 
-int WebMStreamParser::ParseInfoAndTracks(const uint8* data, int size) {
+int WebMStreamParser::ParseInfoAndTracks(const uint8_t* data, int size) {
   DVLOG(2) << "ParseInfoAndTracks()";
   DCHECK(data);
   DCHECK_GT(size, 0);
 
-  const uint8* cur = data;
+  const uint8_t* cur = data;
   int cur_size = size;
   int bytes_parsed = 0;
 
   int id;
-  int64 element_size;
+  int64_t element_size;
   int result = WebMParseElementHeader(cur, cur_size, &id, &element_size);
 
   if (result <= 0)
@@ -201,7 +201,7 @@ int WebMStreamParser::ParseInfoAndTracks(const uint8* data, int size) {
   InitParameters params(kInfiniteDuration());
 
   if (info_parser.duration() > 0) {
-    int64 duration_in_us = info_parser.duration() * timecode_scale_in_us;
+    int64_t duration_in_us = info_parser.duration() * timecode_scale_in_us;
     params.duration = base::TimeDelta::FromMicroseconds(duration_in_us);
   }
 
@@ -247,7 +247,7 @@ int WebMStreamParser::ParseInfoAndTracks(const uint8* data, int size) {
   return bytes_parsed;
 }
 
-int WebMStreamParser::ParseCluster(const uint8* data, int size) {
+int WebMStreamParser::ParseCluster(const uint8_t* data, int size) {
   if (!cluster_parser_)
     return -1;
 
@@ -276,7 +276,7 @@ int WebMStreamParser::ParseCluster(const uint8* data, int size) {
 }
 
 void WebMStreamParser::OnEncryptedMediaInitData(const std::string& key_id) {
-  std::vector<uint8> key_id_vector(key_id.begin(), key_id.end());
+  std::vector<uint8_t> key_id_vector(key_id.begin(), key_id.end());
   encrypted_media_init_data_cb_.Run(EmeInitDataType::WEBM, key_id_vector);
 }
 
diff --git a/media/formats/webm/webm_stream_parser.h b/media/formats/webm/webm_stream_parser.h
index bb53c94..7bcf0d9 100644
--- a/media/formats/webm/webm_stream_parser.h
+++ b/media/formats/webm/webm_stream_parser.h
@@ -31,7 +31,7 @@ class WebMStreamParser : public StreamParser {
             const base::Closure& end_of_segment_cb,
             const scoped_refptr<MediaLog>& media_log) override;
   void Flush() override;
-  bool Parse(const uint8* buf, int size) override;
+  bool Parse(const uint8_t* buf, int size) override;
 
  private:
   enum State {
@@ -51,7 +51,7 @@ class WebMStreamParser : public StreamParser {
   // Returns < 0 if the parse fails.
   // Returns 0 if more data is needed.
   // Returning > 0 indicates success & the number of bytes parsed.
-  int ParseInfoAndTracks(const uint8* data, int size);
+  int ParseInfoAndTracks(const uint8_t* data, int size);
 
   // Incrementally parses WebM cluster elements. This method also skips
   // CUES elements if they are encountered since we currently don't use the
@@ -60,7 +60,7 @@ class WebMStreamParser : public StreamParser {
   // Returns < 0 if the parse fails.
   // Returns 0 if more data is needed.
   // Returning > 0 indicates success & the number of bytes parsed.
-  int ParseCluster(const uint8* data, int size);
+  int ParseCluster(const uint8_t* data, int size);
 
   // Fire needkey event through the |encrypted_media_init_data_cb_|.
   void OnEncryptedMediaInitData(const std::string& key_id);
diff --git a/media/formats/webm/webm_tracks_parser.cc b/media/formats/webm/webm_tracks_parser.cc
index 1f2ca69..464a77ff 100644
--- a/media/formats/webm/webm_tracks_parser.cc
+++ b/media/formats/webm/webm_tracks_parser.cc
@@ -30,11 +30,12 @@ static TextKind CodecIdToTextKind(const std::string& codec_id) {
 }
 
 static base::TimeDelta PrecisionCappedDefaultDuration(
-    const double timecode_scale_in_us, const int64 duration_in_ns) {
+    const double timecode_scale_in_us,
+    const int64_t duration_in_ns) {
   if (duration_in_ns <= 0)
     return kNoTimestamp();
 
-  int64 mult = duration_in_ns / 1000;
+  int64_t mult = duration_in_ns / 1000;
   mult /= timecode_scale_in_us;
   if (mult == 0)
     return kNoTimestamp();
@@ -62,7 +63,7 @@ WebMTracksParser::WebMTracksParser(const scoped_refptr<MediaLog>& media_log,
 
 WebMTracksParser::~WebMTracksParser() {}
 
-int WebMTracksParser::Parse(const uint8* buf, int size) {
+int WebMTracksParser::Parse(const uint8_t* buf, int size) {
   track_type_ =-1;
   track_num_ = -1;
   default_duration_ = -1;
@@ -267,8 +268,8 @@ bool WebMTracksParser::OnListEnd(int id) {
   return true;
 }
 
-bool WebMTracksParser::OnUInt(int id, int64 val) {
-  int64* dst = NULL;
+bool WebMTracksParser::OnUInt(int id, int64_t val) {
+  int64_t* dst = NULL;
 
   switch (id) {
     case kWebMIdTrackNumber:
@@ -304,7 +305,7 @@ bool WebMTracksParser::OnFloat(int id, double val) {
   return true;
 }
 
-bool WebMTracksParser::OnBinary(int id, const uint8* data, int size) {
+bool WebMTracksParser::OnBinary(int id, const uint8_t* data, int size) {
   if (id == kWebMIdCodecPrivate) {
     if (!codec_private_.empty()) {
       MEDIA_LOG(ERROR, media_log_)
diff --git a/media/formats/webm/webm_tracks_parser.h b/media/formats/webm/webm_tracks_parser.h
index d5513b5..2f94cfb 100644
--- a/media/formats/webm/webm_tracks_parser.h
+++ b/media/formats/webm/webm_tracks_parser.h
@@ -36,10 +36,10 @@ class MEDIA_EXPORT WebMTracksParser : public WebMParserClient {
   // Returns -1 if the parse fails.
   // Returns 0 if more data is needed.
   // Returns the number of bytes parsed on success.
-  int Parse(const uint8* buf, int size);
+  int Parse(const uint8_t* buf, int size);
 
-  int64 audio_track_num() const { return audio_track_num_; }
-  int64 video_track_num() const { return video_track_num_; }
+  int64_t audio_track_num() const { return audio_track_num_; }
+  int64_t video_track_num() const { return video_track_num_; }
 
   // If TrackEntry DefaultDuration field existed for the associated audio or
   // video track, returns that value converted from ns to base::TimeDelta with
@@ -50,7 +50,7 @@ class MEDIA_EXPORT WebMTracksParser : public WebMParserClient {
   base::TimeDelta GetVideoDefaultDuration(
       const double timecode_scale_in_us) const;
 
-  const std::set<int64>& ignored_tracks() const { return ignored_tracks_; }
+  const std::set<int64_t>& ignored_tracks() const { return ignored_tracks_; }
 
   const std::string& audio_encryption_key_id() const {
     return audio_encryption_key_id_;
@@ -78,29 +78,29 @@ class MEDIA_EXPORT WebMTracksParser : public WebMParserClient {
   // WebMParserClient implementation.
   WebMParserClient* OnListStart(int id) override;
   bool OnListEnd(int id) override;
-  bool OnUInt(int id, int64 val) override;
+  bool OnUInt(int id, int64_t val) override;
   bool OnFloat(int id, double val) override;
-  bool OnBinary(int id, const uint8* data, int size) override;
+  bool OnBinary(int id, const uint8_t* data, int size) override;
   bool OnString(int id, const std::string& str) override;
 
-  int64 track_type_;
-  int64 track_num_;
+  int64_t track_type_;
+  int64_t track_num_;
   std::string track_name_;
   std::string track_language_;
   std::string codec_id_;
-  std::vector<uint8> codec_private_;
-  int64 seek_preroll_;
-  int64 codec_delay_;
-  int64 default_duration_;
+  std::vector<uint8_t> codec_private_;
+  int64_t seek_preroll_;
+  int64_t codec_delay_;
+  int64_t default_duration_;
   scoped_ptr<WebMContentEncodingsClient> track_content_encodings_client_;
 
-  int64 audio_track_num_;
-  int64 audio_default_duration_;
-  int64 video_track_num_;
-  int64 video_default_duration_;
+  int64_t audio_track_num_;
+  int64_t audio_default_duration_;
+  int64_t video_track_num_;
+  int64_t video_default_duration_;
   bool ignore_text_tracks_;
   TextTracks text_tracks_;
-  std::set<int64> ignored_tracks_;
+  std::set<int64_t> ignored_tracks_;
   std::string audio_encryption_key_id_;
   std::string video_encryption_key_id_;
   scoped_refptr<MediaLog> media_log_;
diff --git a/media/formats/webm/webm_tracks_parser_unittest.cc b/media/formats/webm/webm_tracks_parser_unittest.cc
index 9c424ec..7e5a067 100644
--- a/media/formats/webm/webm_tracks_parser_unittest.cc
+++ b/media/formats/webm/webm_tracks_parser_unittest.cc
@@ -27,7 +27,7 @@ class WebMTracksParserTest : public testing::Test {
   WebMTracksParserTest() : media_log_(new StrictMock<MockMediaLog>()) {}
 
  protected:
-  void VerifyTextTrackInfo(const uint8* buffer,
+  void VerifyTextTrackInfo(const uint8_t* buffer,
                            int buffer_size,
                            TextKind text_kind,
                            const std::string& name,
@@ -61,7 +61,7 @@ TEST_F(WebMTracksParserTest, SubtitleNoNameNoLang) {
   TracksBuilder tb;
   tb.AddTextTrack(1, 1, kWebMCodecSubtitles, "", "");
 
-  const std::vector<uint8> buf = tb.Finish();
+  const std::vector<uint8_t> buf = tb.Finish();
   VerifyTextTrackInfo(&buf[0], buf.size(), kTextSubtitles, "", "");
 }
 
@@ -71,7 +71,7 @@ TEST_F(WebMTracksParserTest, SubtitleYesNameNoLang) {
   TracksBuilder tb;
   tb.AddTextTrack(1, 1, kWebMCodecSubtitles, "Spock", "");
 
-  const std::vector<uint8> buf = tb.Finish();
+  const std::vector<uint8_t> buf = tb.Finish();
   VerifyTextTrackInfo(&buf[0], buf.size(), kTextSubtitles, "Spock", "");
 }
 
@@ -81,7 +81,7 @@ TEST_F(WebMTracksParserTest, SubtitleNoNameYesLang) {
   TracksBuilder tb;
   tb.AddTextTrack(1, 1, kWebMCodecSubtitles, "", "eng");
 
-  const std::vector<uint8> buf = tb.Finish();
+  const std::vector<uint8_t> buf = tb.Finish();
   VerifyTextTrackInfo(&buf[0], buf.size(), kTextSubtitles, "", "eng");
 }
 
@@ -91,7 +91,7 @@ TEST_F(WebMTracksParserTest, SubtitleYesNameYesLang) {
   TracksBuilder tb;
   tb.AddTextTrack(1, 1, kWebMCodecSubtitles, "Picard", "fre");
 
-  const std::vector<uint8> buf = tb.Finish();
+  const std::vector<uint8_t> buf = tb.Finish();
   VerifyTextTrackInfo(&buf[0], buf.size(), kTextSubtitles, "Picard", "fre");
 }
 
@@ -102,7 +102,7 @@ TEST_F(WebMTracksParserTest, IgnoringTextTracks) {
   tb.AddTextTrack(1, 1, kWebMCodecSubtitles, "Subtitles", "fre");
   tb.AddTextTrack(2, 2, kWebMCodecSubtitles, "Commentary", "fre");
 
-  const std::vector<uint8> buf = tb.Finish();
+  const std::vector<uint8_t> buf = tb.Finish();
   scoped_ptr<WebMTracksParser> parser(new WebMTracksParser(media_log_, true));
 
   EXPECT_MEDIA_LOG(HasSubstr("Ignoring text track 1"));
@@ -114,7 +114,7 @@ TEST_F(WebMTracksParserTest, IgnoringTextTracks) {
 
   EXPECT_EQ(parser->text_tracks().size(), 0u);
 
-  const std::set<int64>& ignored_tracks = parser->ignored_tracks();
+  const std::set<int64_t>& ignored_tracks = parser->ignored_tracks();
   EXPECT_TRUE(ignored_tracks.find(1) != ignored_tracks.end());
   EXPECT_TRUE(ignored_tracks.find(2) != ignored_tracks.end());
 
@@ -137,7 +137,7 @@ TEST_F(WebMTracksParserTest, AudioVideoDefaultDurationUnset) {
   TracksBuilder tb;
   tb.AddAudioTrack(1, 1, "A_VORBIS", "audio", "", -1, 2, 8000);
   tb.AddVideoTrack(2, 2, "V_VP8", "video", "", -1, 320, 240);
-  const std::vector<uint8> buf = tb.Finish();
+  const std::vector<uint8_t> buf = tb.Finish();
 
   scoped_ptr<WebMTracksParser> parser(new WebMTracksParser(media_log_, true));
   int result = parser->Parse(&buf[0], buf.size());
@@ -166,7 +166,7 @@ TEST_F(WebMTracksParserTest, AudioVideoDefaultDurationSet) {
   TracksBuilder tb;
   tb.AddAudioTrack(1, 1, "A_VORBIS", "audio", "", 12345678, 2, 8000);
   tb.AddVideoTrack(2, 2, "V_VP8", "video", "", 987654321, 320, 240);
-  const std::vector<uint8> buf = tb.Finish();
+  const std::vector<uint8_t> buf = tb.Finish();
 
   scoped_ptr<WebMTracksParser> parser(new WebMTracksParser(media_log_, true));
   int result = parser->Parse(&buf[0], buf.size());
@@ -188,7 +188,7 @@ TEST_F(WebMTracksParserTest, InvalidZeroDefaultDurationSet) {
   // Confirm parse error if TrackEntry DefaultDuration is present, but is 0ns.
   TracksBuilder tb(true);
   tb.AddAudioTrack(1, 1, "A_VORBIS", "audio", "", 0, 2, 8000);
-  const std::vector<uint8> buf = tb.Finish();
+  const std::vector<uint8_t> buf = tb.Finish();
 
   scoped_ptr<WebMTracksParser> parser(new WebMTracksParser(media_log_, true));
 
@@ -202,7 +202,7 @@ TEST_F(WebMTracksParserTest, HighTrackUID) {
   // (http://crbug.com/397067).
   TracksBuilder tb(true);
   tb.AddAudioTrack(1, 1ULL << 31, "A_VORBIS", "audio", "", 40, 2, 8000);
-  const std::vector<uint8> buf = tb.Finish();
+  const std::vector<uint8_t> buf = tb.Finish();
 
   scoped_ptr<WebMTracksParser> parser(new WebMTracksParser(media_log_, true));
   EXPECT_GT(parser->Parse(&buf[0], buf.size()),0);
diff --git a/media/formats/webm/webm_video_client.cc b/media/formats/webm/webm_video_client.cc
index 29b7dca..6e57dfb 100644
--- a/media/formats/webm/webm_video_client.cc
+++ b/media/formats/webm/webm_video_client.cc
@@ -31,8 +31,10 @@ void WebMVideoClient::Reset() {
 }
 
 bool WebMVideoClient::InitializeConfig(
-    const std::string& codec_id, const std::vector<uint8>& codec_private,
-    bool is_encrypted, VideoDecoderConfig* config) {
+    const std::string& codec_id,
+    const std::vector<uint8_t>& codec_private,
+    bool is_encrypted,
+    VideoDecoderConfig* config) {
   DCHECK(config);
 
   VideoCodec video_codec = kUnknownVideoCodec;
@@ -95,8 +97,8 @@ bool WebMVideoClient::InitializeConfig(
   return config->IsValidConfig();
 }
 
-bool WebMVideoClient::OnUInt(int id, int64 val) {
-  int64* dst = NULL;
+bool WebMVideoClient::OnUInt(int id, int64_t val) {
+  int64_t* dst = NULL;
 
   switch (id) {
     case kWebMIdPixelWidth:
@@ -144,7 +146,7 @@ bool WebMVideoClient::OnUInt(int id, int64 val) {
   return true;
 }
 
-bool WebMVideoClient::OnBinary(int id, const uint8* data, int size) {
+bool WebMVideoClient::OnBinary(int id, const uint8_t* data, int size) {
   // Accept binary fields we don't care about for now.
   return true;
 }
diff --git a/media/formats/webm/webm_video_client.h b/media/formats/webm/webm_video_client.h
index f2f1df4..12a6cbb 100644
--- a/media/formats/webm/webm_video_client.h
+++ b/media/formats/webm/webm_video_client.h
@@ -31,27 +31,27 @@ class WebMVideoClient : public WebMParserClient {
   // video track element fields. The contents of |config| are undefined in this
   // case and should not be relied upon.
   bool InitializeConfig(const std::string& codec_id,
-                        const std::vector<uint8>& codec_private,
+                        const std::vector<uint8_t>& codec_private,
                         bool is_encrypted,
                         VideoDecoderConfig* config);
 
  private:
   // WebMParserClient implementation.
-  bool OnUInt(int id, int64 val) override;
-  bool OnBinary(int id, const uint8* data, int size) override;
+  bool OnUInt(int id, int64_t val) override;
+  bool OnBinary(int id, const uint8_t* data, int size) override;
   bool OnFloat(int id, double val) override;
 
   scoped_refptr<MediaLog> media_log_;
-  int64 pixel_width_;
-  int64 pixel_height_;
-  int64 crop_bottom_;
-  int64 crop_top_;
-  int64 crop_left_;
-  int64 crop_right_;
-  int64 display_width_;
-  int64 display_height_;
-  int64 display_unit_;
-  int64 alpha_mode_;
+  int64_t pixel_width_;
+  int64_t pixel_height_;
+  int64_t crop_bottom_;
+  int64_t crop_top_;
+  int64_t crop_left_;
+  int64_t crop_right_;
+  int64_t display_width_;
+  int64_t display_height_;
+  int64_t display_unit_;
+  int64_t alpha_mode_;
 
   DISALLOW_COPY_AND_ASSIGN(WebMVideoClient);
 };
diff --git a/media/formats/webm/webm_webvtt_parser.cc b/media/formats/webm/webm_webvtt_parser.cc
index 64de1ef..d84009c 100644
--- a/media/formats/webm/webm_webvtt_parser.cc
+++ b/media/formats/webm/webm_webvtt_parser.cc
@@ -6,7 +6,8 @@
 
 namespace media {
 
-void WebMWebVTTParser::Parse(const uint8* payload, int payload_size,
+void WebMWebVTTParser::Parse(const uint8_t* payload,
+                             int payload_size,
                              std::string* id,
                              std::string* settings,
                              std::string* content) {
@@ -14,10 +15,8 @@ void WebMWebVTTParser::Parse(const uint8* payload, int payload_size,
   parser.Parse(id, settings, content);
 }
 
-WebMWebVTTParser::WebMWebVTTParser(const uint8* payload, int payload_size)
-    : ptr_(payload),
-      ptr_end_(payload + payload_size) {
-}
+WebMWebVTTParser::WebMWebVTTParser(const uint8_t* payload, int payload_size)
+    : ptr_(payload), ptr_end_(payload + payload_size) {}
 
 void WebMWebVTTParser::Parse(std::string* id,
                              std::string* settings,
@@ -27,7 +26,7 @@ void WebMWebVTTParser::Parse(std::string* id,
   content->assign(ptr_, ptr_end_);
 }
 
-bool WebMWebVTTParser::GetByte(uint8* byte) {
+bool WebMWebVTTParser::GetByte(uint8_t* byte) {
   if (ptr_ >= ptr_end_)
     return false;  // indicates end-of-stream
 
@@ -59,7 +58,7 @@ void WebMWebVTTParser::ParseLine(std::string* line) {
   };
 
   for (;;) {
-    uint8 byte;
+    uint8_t byte;
 
     if (!GetByte(&byte) || byte == kLF)
       return;
diff --git a/media/formats/webm/webm_webvtt_parser.h b/media/formats/webm/webm_webvtt_parser.h
index 12bbbd4..75c3864 100644
--- a/media/formats/webm/webm_webvtt_parser.h
+++ b/media/formats/webm/webm_webvtt_parser.h
@@ -5,9 +5,11 @@
 #ifndef MEDIA_FORMATS_WEBM_WEBM_WEBVTT_PARSER_H_
 #define MEDIA_FORMATS_WEBM_WEBM_WEBVTT_PARSER_H_
 
+#include <stdint.h>
+
 #include <string>
 
-#include "base/basictypes.h"
+#include "base/macros.h"
 #include "media/base/media_export.h"
 
 namespace media {
@@ -15,7 +17,8 @@ namespace media {
 class MEDIA_EXPORT WebMWebVTTParser {
  public:
   // Utility function to parse the WebVTT cue from a byte stream.
-  static void Parse(const uint8* payload, int payload_size,
+  static void Parse(const uint8_t* payload,
+                    int payload_size,
                     std::string* id,
                     std::string* settings,
                     std::string* content);
@@ -23,13 +26,13 @@ class MEDIA_EXPORT WebMWebVTTParser {
  private:
   // The payload is the embedded WebVTT cue, stored in a WebM block.
   // The parser treats this as a UTF-8 byte stream.
-  WebMWebVTTParser(const uint8* payload, int payload_size);
+  WebMWebVTTParser(const uint8_t* payload, int payload_size);
 
   // Parse the cue identifier, settings, and content from the stream.
   void Parse(std::string* id, std::string* settings, std::string* content);
   // Remove a byte from the stream, advancing the stream pointer.
   // Returns true if a character was returned; false means "end of stream".
-  bool GetByte(uint8* byte);
+  bool GetByte(uint8_t* byte);
 
   // Backup the stream pointer.
   void UngetByte();
@@ -38,8 +41,8 @@ class MEDIA_EXPORT WebMWebVTTParser {
   void ParseLine(std::string* line);
 
   // Represents the portion of the stream that has not been consumed yet.
-  const uint8* ptr_;
-  const uint8* const ptr_end_;
+  const uint8_t* ptr_;
+  const uint8_t* const ptr_end_;
 
   DISALLOW_COPY_AND_ASSIGN(WebMWebVTTParser);
 };
diff --git a/media/formats/webm/webm_webvtt_parser_unittest.cc b/media/formats/webm/webm_webvtt_parser_unittest.cc
index ecdabd4..c40d1a1 100644
--- a/media/formats/webm/webm_webvtt_parser_unittest.cc
+++ b/media/formats/webm/webm_webvtt_parser_unittest.cc
@@ -10,13 +10,13 @@ using ::testing::InSequence;
 
 namespace media {
 
-typedef std::vector<uint8> Cue;
+typedef std::vector<uint8_t> Cue;
 
 static Cue EncodeCue(const std::string& id,
                      const std::string& settings,
                      const std::string& content) {
   const std::string result = id + '\n' + settings + '\n' + content;
-  const uint8* const buf = reinterpret_cast<const uint8*>(result.data());
+  const uint8_t* const buf = reinterpret_cast<const uint8_t*>(result.data());
   return Cue(buf, buf + result.length());
 }