Switch to standard integer types in media/.

media/base/seekable_buffer.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/base/seekable_buffer.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "media/base/data_buffer.h"
@@ skipping 16 matching lines @@
 
 void SeekableBuffer::Clear() {
   buffers_.clear();
   current_buffer_ = buffers_.begin();
   current_buffer_offset_ = 0;
   backward_bytes_ = 0;
   forward_bytes_ = 0;
   current_time_ = kNoTimestamp();
 }
 
-int SeekableBuffer::Read(uint8* data, int size) {
+int SeekableBuffer::Read(uint8_t* data, int size) {
   DCHECK(data);
   return InternalRead(data, size, true, 0);
 }
 
-int SeekableBuffer::Peek(uint8* data, int size, int forward_offset) {
+int SeekableBuffer::Peek(uint8_t* data, int size, int forward_offset) {
   DCHECK(data);
   return InternalRead(data, size, false, forward_offset);
 }
 
-bool SeekableBuffer::GetCurrentChunk(const uint8** data, int* size) const {
+bool SeekableBuffer::GetCurrentChunk(const uint8_t** data, int* size) const {
   BufferQueue::iterator current_buffer = current_buffer_;
   int current_buffer_offset = current_buffer_offset_;
   // Advance position if we are in the end of the current buffer.
   while (current_buffer != buffers_.end() &&
          current_buffer_offset >= (*current_buffer)->data_size()) {
     ++current_buffer;
     current_buffer_offset = 0;
   }
   if (current_buffer == buffers_.end())
     return false;
@@ skipping 22 matching lines @@
   forward_bytes_ += buffer_in->data_size();
 
   // Advise the user to stop append if the amount of forward bytes exceeds
   // the forward capacity. A false return value means the user should stop
   // appending more data to this buffer.
   if (forward_bytes_ >= forward_capacity_)
     return false;
   return true;
 }
 
-bool SeekableBuffer::Append(const uint8* data, int size) {
+bool SeekableBuffer::Append(const uint8_t* data, int size) {
   if (size > 0) {
     scoped_refptr<DataBuffer> data_buffer = DataBuffer::CopyFrom(data, size);
     return Append(data_buffer);
   } else {
     // Return true if we have forward capacity.
     return forward_bytes_ < forward_capacity_;
   }
 }
 
-bool SeekableBuffer::Seek(int32 offset) {
+bool SeekableBuffer::Seek(int32_t offset) {
   if (offset > 0)
     return SeekForward(offset);
   else if (offset < 0)
     return SeekBackward(-offset);
   return true;
 }
 
 bool SeekableBuffer::SeekForward(int size) {
   // Perform seeking forward only if we have enough bytes in the queue.
   if (size > forward_bytes_)
@@ skipping 62 matching lines @@
     if (i == current_buffer_)
       break;
     scoped_refptr<DataBuffer> buffer = *i;
     backward_bytes_ -= buffer->data_size();
     DCHECK_GE(backward_bytes_, 0);
 
     buffers_.erase(i);
   }
 }
 
-int SeekableBuffer::InternalRead(uint8* data, int size,
+int SeekableBuffer::InternalRead(uint8_t* data,
+                                 int size,
                                  bool advance_position,
                                  int forward_offset) {
   // Counts how many bytes are actually read from the buffer queue.
   int taken = 0;
 
   BufferQueue::iterator current_buffer = current_buffer_;
   int current_buffer_offset = current_buffer_offset_;
 
   int bytes_to_skip = forward_offset;
   while (taken < size) {
@@ skipping 66 matching lines @@
   }
 
   return taken;
 }
 
 void SeekableBuffer::UpdateCurrentTime(BufferQueue::iterator buffer,
                                        int offset) {
   // Garbage values are unavoidable, so this check will remain.
   if (buffer != buffers_.end() &&
       (*buffer)->timestamp() != kNoTimestamp()) {
-    int64 time_offset = ((*buffer)->duration().InMicroseconds() * offset) /
-                        (*buffer)->data_size();
+    int64_t time_offset = ((*buffer)->duration().InMicroseconds() * offset) /
+                          (*buffer)->data_size();
 
     current_time_ = (*buffer)->timestamp() +
                     base::TimeDelta::FromMicroseconds(time_offset);
   }
 }
 
 }  // namespace media