Switch to standard integer types in media/.

media/filters/frame_processor_unittest.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 <map>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 110 matching lines @@
         buffer_timestamps.push_back(buffer_timestamps[0]);
       CHECK_EQ(2u, buffer_timestamps.size());
 
       double time_in_ms, decode_time_in_ms;
       CHECK(base::StringToDouble(buffer_timestamps[0], &time_in_ms));
       CHECK(base::StringToDouble(buffer_timestamps[1], &decode_time_in_ms));
 
       // Create buffer. Encode the original time_in_ms as the buffer's data to
       // enable later verification of possible buffer relocation in presentation
       // timeline due to coded frame processing.
-      const uint8* timestamp_as_data = reinterpret_cast<uint8*>(&time_in_ms);
+      const uint8_t* timestamp_as_data =
+          reinterpret_cast<uint8_t*>(&time_in_ms);
       scoped_refptr<StreamParserBuffer> buffer =
           StreamParserBuffer::CopyFrom(timestamp_as_data, sizeof(time_in_ms),
                                        is_keyframe, type, track_id);
       base::TimeDelta timestamp = base::TimeDelta::FromSecondsD(
           time_in_ms / base::Time::kMillisecondsPerSecond);
       buffer->set_timestamp(timestamp);
       if (time_in_ms != decode_time_in_ms) {
         DecodeTimestamp decode_timestamp = DecodeTimestamp::FromSecondsD(
             decode_time_in_ms / base::Time::kMillisecondsPerSecond);
         buffer->SetDecodeTimestamp(decode_timestamp);
@@ skipping 16 matching lines @@
   }
 
   void CheckExpectedRangesByTimestamp(ChunkDemuxerStream* stream,
                                       const std::string& expected) {
     // Note, DemuxerStream::TEXT streams return [0,duration (==infinity here))
     Ranges<base::TimeDelta> r = stream->GetBufferedRanges(kInfiniteDuration());
 
     std::stringstream ss;
     ss << "{ ";
     for (size_t i = 0; i < r.size(); ++i) {
-      int64 start = r.start(i).InMilliseconds();
-      int64 end = r.end(i).InMilliseconds();
+      int64_t start = r.start(i).InMilliseconds();
+      int64_t end = r.end(i).InMilliseconds();
       ss << "[" << start << "," << end << ") ";
     }
     ss << "}";
     EXPECT_EQ(expected, ss.str());
   }
 
   void CheckReadStalls(ChunkDemuxerStream* stream) {
     int loop_count = 0;
 
     do {
@@ skipping 572 matching lines @@
   EXPECT_EQ(frame_duration_ * -9, timestamp_offset_);
   EXPECT_FALSE(new_media_segment_);
   CheckExpectedRangesByTimestamp(audio_.get(), "{ [0,20) }");
   CheckReadsThenReadStalls(audio_.get(), "0 10:100");
 }
 
 INSTANTIATE_TEST_CASE_P(SequenceMode, FrameProcessorTest, Values(true));
 INSTANTIATE_TEST_CASE_P(SegmentsMode, FrameProcessorTest, Values(false));
 
 }  // namespace media