Switch to standard integer types in media/.

media/filters/source_buffer_stream_unittest.cc

 // 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.
 
 #include "media/filters/source_buffer_stream.h"
 
 #include <stdint.h>
 #include <string>
 #include <vector>
 
@@ skipping 16 matching lines @@
 using ::testing::HasSubstr;
 using ::testing::InSequence;
 using ::testing::StrictMock;
 
 namespace media {
 
 typedef StreamParser::BufferQueue BufferQueue;
 
 static const int kDefaultFramesPerSecond = 30;
 static const int kDefaultKeyframesPerSecond = 6;
-static const uint8 kDataA = 0x11;
-static const uint8 kDataB = 0x33;
+static const uint8_t kDataA = 0x11;
+static const uint8_t kDataB = 0x33;
 static const int kDataSize = 1;
 
 // Matchers for verifying common media log entry strings.
 MATCHER(ContainsMissingKeyframeLog, "") {
   return CONTAINS_STRING(arg,
                          "Media segment did not begin with key frame. Support "
                          "for such segments will be available in a future "
                          "version. Please see https://crbug.com/229412.");
 }
 
@@ skipping 62 matching lines @@
 
     // Equivalent to 2ms per frame.
     SetStreamInfo(500, 500);
   }
 
   void NewSegmentAppend(int starting_position, int number_of_buffers) {
     AppendBuffers(starting_position, number_of_buffers, true,
                   base::TimeDelta(), true, &kDataA, kDataSize);
   }
 
-  void NewSegmentAppend(int starting_position, int number_of_buffers,
-                        const uint8* data) {
+  void NewSegmentAppend(int starting_position,
+                        int number_of_buffers,
+                        const uint8_t* data) {
     AppendBuffers(starting_position, number_of_buffers, true,
                   base::TimeDelta(), true, data, kDataSize);
   }
 
   void NewSegmentAppend_OffsetFirstBuffer(
       int starting_position, int number_of_buffers,
       base::TimeDelta first_buffer_offset) {
     AppendBuffers(starting_position, number_of_buffers, true,
                   first_buffer_offset, true, &kDataA, kDataSize);
   }
 
   void NewSegmentAppend_ExpectFailure(
       int starting_position, int number_of_buffers) {
     AppendBuffers(starting_position, number_of_buffers, true,
                   base::TimeDelta(), false, &kDataA, kDataSize);
   }
 
   void AppendBuffers(int starting_position, int number_of_buffers) {
     AppendBuffers(starting_position, number_of_buffers, false,
                   base::TimeDelta(), true, &kDataA, kDataSize);
   }
 
-  void AppendBuffers(int starting_position, int number_of_buffers,
-                     const uint8* data) {
+  void AppendBuffers(int starting_position,
+                     int number_of_buffers,
+                     const uint8_t* data) {
     AppendBuffers(starting_position, number_of_buffers, false,
                   base::TimeDelta(), true, data, kDataSize);
   }
 
   void NewSegmentAppend(const std::string& buffers_to_append) {
     AppendBuffers(buffers_to_append, true, kNoTimestamp(), false, true);
   }
 
   void NewSegmentAppend(base::TimeDelta start_timestamp,
                         const std::string& buffers_to_append) {
@@ skipping 56 matching lines @@
     *removal_end = removal_end_timestamp.InMilliseconds();
     return bytes_removed;
   }
 
   void CheckExpectedRanges(const std::string& expected) {
     Ranges<base::TimeDelta> r = stream_->GetBufferedTime();
 
     std::stringstream ss;
     ss << "{ ";
     for (size_t i = 0; i < r.size(); ++i) {
-      int64 start = (r.start(i) / frame_duration_);
-      int64 end = (r.end(i) / frame_duration_) - 1;
+      int64_t start = (r.start(i) / frame_duration_);
+      int64_t end = (r.end(i) / frame_duration_) - 1;
       ss << "[" << start << "," << end << ") ";
     }
     ss << "}";
     EXPECT_EQ(expected, ss.str());
   }
 
   void CheckExpectedRangesByTimestamp(const std::string& expected) {
     Ranges<base::TimeDelta> r = stream_->GetBufferedTime();
 
     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 CheckExpectedBuffers(
       int starting_position, int ending_position) {
     CheckExpectedBuffers(starting_position, ending_position, false, NULL, 0);
   }
 
   void CheckExpectedBuffers(
       int starting_position, int ending_position, bool expect_keyframe) {
     CheckExpectedBuffers(starting_position, ending_position, expect_keyframe,
                          NULL, 0);
   }
 
-  void CheckExpectedBuffers(
-      int starting_position, int ending_position, const uint8* data) {
+  void CheckExpectedBuffers(int starting_position,
+                            int ending_position,
+                            const uint8_t* data) {
     CheckExpectedBuffers(starting_position, ending_position, false, data,
                          kDataSize);
   }
 
-  void CheckExpectedBuffers(
-      int starting_position, int ending_position, const uint8* data,
-      bool expect_keyframe) {
+  void CheckExpectedBuffers(int starting_position,
+                            int ending_position,
+                            const uint8_t* data,
+                            bool expect_keyframe) {
     CheckExpectedBuffers(starting_position, ending_position, expect_keyframe,
                          data, kDataSize);
   }
 
-  void CheckExpectedBuffers(
-      int starting_position, int ending_position, bool expect_keyframe,
-      const uint8* expected_data, int expected_size) {
+  void CheckExpectedBuffers(int starting_position,
+                            int ending_position,
+                            bool expect_keyframe,
+                            const uint8_t* expected_data,
+                            int expected_size) {
     int current_position = starting_position;
     for (; current_position <= ending_position; current_position++) {
       scoped_refptr<StreamParserBuffer> buffer;
       SourceBufferStream::Status status = stream_->GetNextBuffer(&buffer);
 
       EXPECT_NE(status, SourceBufferStream::kConfigChange);
       if (status != SourceBufferStream::kSuccess)
         break;
 
       if (expect_keyframe && current_position == starting_position)
         EXPECT_TRUE(buffer->is_key_frame());
 
       if (expected_data) {
-        const uint8* actual_data = buffer->data();
+        const uint8_t* actual_data = buffer->data();
         const int actual_size = buffer->data_size();
         EXPECT_EQ(expected_size, actual_size);
         for (int i = 0; i < std::min(actual_size, expected_size); i++) {
           EXPECT_EQ(expected_data[i], actual_data[i]);
         }
       }
 
       EXPECT_EQ(buffer->GetDecodeTimestamp() / frame_duration_,
                 current_position);
     }
@@ skipping 131 matching lines @@
   base::TimeDelta ConvertToFrameDuration(int frames_per_second) {
     return base::TimeDelta::FromMicroseconds(
         base::Time::kMicrosecondsPerSecond / frames_per_second);
   }
 
   void AppendBuffers(int starting_position,
                      int number_of_buffers,
                      bool begin_media_segment,
                      base::TimeDelta first_buffer_offset,
                      bool expect_success,
-                     const uint8* data,
+                     const uint8_t* data,
                      int size) {
     if (begin_media_segment)
       stream_->OnNewMediaSegment(DecodeTimestamp::FromPresentationTime(
           starting_position * frame_duration_));
 
     int keyframe_interval = frames_per_second_ / keyframes_per_second_;
 
     BufferQueue queue;
     for (int i = 0; i < number_of_buffers; i++) {
       int position = starting_position + i;
@@ skipping 604 matching lines @@
 
   // Seek back to beginning; all data should be new.
   Seek(5);
   CheckExpectedBuffers(5, 14, &kDataB);
 
   // Check range continues to be correct.
   CheckExpectedRanges("{ [5,14) }");
 }
 
 TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected_Multiple) {
-  static const uint8 kDataC = 0x55;
-  static const uint8 kDataD = 0x77;
+  static const uint8_t kDataC = 0x55;
+  static const uint8_t kDataD = 0x77;
 
   // Append 5 buffers at positions 5 through 9.
   NewSegmentAppend(5, 5, &kDataA);
 
   // Seek to buffer at position 5 and get next buffer.
   Seek(5);
   CheckExpectedBuffers(5, 5, &kDataA);
 
   // Replace existing data with new data.
   NewSegmentAppend(5, 5, &kDataB);
@@ skipping 3538 matching lines @@
   CheckNoNextBuffer();
 }
 
 // TODO(vrk): Add unit tests where keyframes are unaligned between streams.
 // (crbug.com/133557)
 
 // TODO(vrk): Add unit tests with end of stream being called at interesting
 // times.
 
 }  // namespace media