Switch to standard integer types in media/.

media/base/seekable_buffer_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 <cstdlib>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "media/base/data_buffer.h"
@@ skipping 23 matching lines @@
     // Create random test data samples.
     for (int i = 0; i < kDataSize; i++)
       data_[i] = static_cast<char>(rand());
   }
 
   int GetRandomInt(int maximum) {
     return rand() % (maximum + 1);
   }
 
   SeekableBuffer buffer_;
-  uint8 data_[kDataSize];
-  uint8 write_buffer_[kDataSize];
+  uint8_t data_[kDataSize];
+  uint8_t write_buffer_[kDataSize];
 };
 
 TEST_F(SeekableBufferTest, RandomReadWrite) {
   int write_position = 0;
   int read_position = 0;
   while (read_position < kDataSize) {
     // Write a random amount of data.
     int write_size = GetRandomInt(kBufferSize);
     write_size = std::min(write_size, kDataSize - write_position);
     bool should_append = buffer_.Append(data_ + write_position, write_size);
@@ skipping 56 matching lines @@
       EXPECT_EQ(0, memcmp(write_buffer_, data_ + read_position, kReadSize));
 
       // Read.
       EXPECT_EQ(kReadSize, buffer_.Read(write_buffer_, kReadSize));
       forward_bytes -= kReadSize;
       EXPECT_EQ(forward_bytes, buffer_.forward_bytes());
       EXPECT_EQ(0, memcmp(write_buffer_, data_ + read_position, kReadSize));
       read_position += kReadSize;
 
       // Seek backward.
-      EXPECT_TRUE(buffer_.Seek(-3 * static_cast<int32>(kReadSize)));
+      EXPECT_TRUE(buffer_.Seek(-3 * static_cast<int32_t>(kReadSize)));
       forward_bytes += 3 * kReadSize;
       read_position -= 3 * kReadSize;
       EXPECT_EQ(forward_bytes, buffer_.forward_bytes());
 
       // Copy.
       EXPECT_EQ(kReadSize, buffer_.Peek(write_buffer_, kReadSize));
       EXPECT_EQ(forward_bytes, buffer_.forward_bytes());
       EXPECT_EQ(0, memcmp(write_buffer_, data_ + read_position, kReadSize));
 
       // Read.
@@ skipping 76 matching lines @@
     buffer_.Append(data_ + i, kWriteSize);
   }
 
   // Read until buffer is empty.
   for (int i = 0; i < kBufferSize; i += kReadSize) {
     EXPECT_EQ(kReadSize, buffer_.Read(write_buffer_, kReadSize));
     EXPECT_EQ(0, memcmp(write_buffer_, data_ + i, kReadSize));
   }
 
   // Seek backward.
-  EXPECT_TRUE(buffer_.Seek(-static_cast<int32>(kBufferSize)));
+  EXPECT_TRUE(buffer_.Seek(-static_cast<int32_t>(kBufferSize)));
   EXPECT_FALSE(buffer_.Seek(-1));
 
   // Read again.
   for (int i = 0; i < kBufferSize; i += kReadSize) {
     EXPECT_EQ(kReadSize, buffer_.Read(write_buffer_, kReadSize));
     EXPECT_EQ(0, memcmp(write_buffer_, data_ + i, kReadSize));
   }
 }
 
 TEST_F(SeekableBufferTest, GetCurrentChunk) {
   const int kSeekSize = kWriteSize / 3;
 
   scoped_refptr<DataBuffer> buffer = DataBuffer::CopyFrom(data_, kWriteSize);
 
-  const uint8* data;
+  const uint8_t* data;
   int size;
   EXPECT_FALSE(buffer_.GetCurrentChunk(&data, &size));
 
   buffer_.Append(buffer.get());
   EXPECT_TRUE(buffer_.GetCurrentChunk(&data, &size));
   EXPECT_EQ(data, buffer->data());
   EXPECT_EQ(size, buffer->data_size());
 
   buffer_.Seek(kSeekSize);
   EXPECT_TRUE(buffer_.GetCurrentChunk(&data, &size));
@@ skipping 40 matching lines @@
   EXPECT_EQ(0, buffer_.Read(write_buffer_, 0));
   EXPECT_EQ(0, buffer_.Read(write_buffer_, 1));
   EXPECT_TRUE(buffer_.Seek(0));
   EXPECT_FALSE(buffer_.Seek(-1));
   EXPECT_FALSE(buffer_.Seek(1));
   EXPECT_EQ(0, buffer_.forward_bytes());
   EXPECT_EQ(0, buffer_.backward_bytes());
 }
 
 TEST_F(SeekableBufferTest, GetTime) {
-  const int64 kNoTS = kNoTimestamp().ToInternalValue();
+  const int64_t kNoTS = kNoTimestamp().ToInternalValue();
   const struct {
-    int64 first_time_useconds;
-    int64 duration_useconds;
+    int64_t first_time_useconds;
+    int64_t duration_useconds;
     int consume_bytes;
-    int64 expected_time;
+    int64_t expected_time;
   } tests[] = {
     { kNoTS, 1000000, 0, kNoTS },
     { kNoTS, 4000000, 0, kNoTS },
     { kNoTS, 8000000, 0, kNoTS },
     { kNoTS, 1000000, kWriteSize / 2, kNoTS },
     { kNoTS, 4000000, kWriteSize / 2, kNoTS },
     { kNoTS, 8000000, kWriteSize / 2, kNoTS },
     { kNoTS, 1000000, kWriteSize, kNoTS },
     { kNoTS, 4000000, kWriteSize, kNoTS },
     { kNoTS, 8000000, kWriteSize, kNoTS },
@@ skipping 24 matching lines @@
   scoped_refptr<DataBuffer> buffer = DataBuffer::CopyFrom(data_, kWriteSize);
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     buffer->set_timestamp(base::TimeDelta::FromMicroseconds(
         tests[i].first_time_useconds));
     buffer->set_duration(base::TimeDelta::FromMicroseconds(
         tests[i].duration_useconds));
     buffer_.Append(buffer.get());
     EXPECT_TRUE(buffer_.Seek(tests[i].consume_bytes));
 
-    int64 actual = buffer_.current_time().ToInternalValue();
+    int64_t actual = buffer_.current_time().ToInternalValue();
 
     EXPECT_EQ(tests[i].expected_time, actual) << "With test = { start:"
         << tests[i].first_time_useconds << ", duration:"
         << tests[i].duration_useconds << ", consumed:"
         << tests[i].consume_bytes << " }\n";
 
     buffer_.Clear();
   }
 }
 
 }  // namespace media