Switch to standard integer types in chrome/.

chrome/common/partial_circular_buffer.cc

Index: chrome/common/partial_circular_buffer.cc
diff --git a/chrome/common/partial_circular_buffer.cc b/chrome/common/partial_circular_buffer.cc
index 6e3e017e991f080a87f980f091a6b03b13230c83..c93a4b3ce214ac6ea82a39ecf902531c8e128da6 100644
--- a/chrome/common/partial_circular_buffer.cc
+++ b/chrome/common/partial_circular_buffer.cc
@@ -10,21 +10,20 @@
 
 namespace {
 
-inline uint32 Min3(uint32 a, uint32 b, uint32 c) {
+inline uint32_t Min3(uint32_t a, uint32_t b, uint32_t c) {
   return std::min(a, std::min(b, c));
 }
 
 }  // namespace
 
-PartialCircularBuffer::PartialCircularBuffer(void* buffer,
-                                             uint32 buffer_size)
+PartialCircularBuffer::PartialCircularBuffer(void* buffer, uint32_t buffer_size)
     : buffer_data_(reinterpret_cast<BufferData*>(buffer)),
       memory_buffer_size_(buffer_size),
       data_size_(0),
       position_(0),
       total_read_(0) {
-  uint32 header_size =
-      buffer_data_->data - reinterpret_cast<uint8*>(buffer_data_);
+  uint32_t header_size =
+      buffer_data_->data - reinterpret_cast<uint8_t*>(buffer_data_);
   data_size_ = memory_buffer_size_ - header_size;
 
   DCHECK(buffer_data_);
@@ -35,16 +34,16 @@ PartialCircularBuffer::PartialCircularBuffer(void* buffer,
 }
 
 PartialCircularBuffer::PartialCircularBuffer(void* buffer,
-                                             uint32 buffer_size,
-                                             uint32 wrap_position,
+                                             uint32_t buffer_size,
+                                             uint32_t wrap_position,
                                              bool append)
     : buffer_data_(reinterpret_cast<BufferData*>(buffer)),
       memory_buffer_size_(buffer_size),
       data_size_(0),
       position_(0),
       total_read_(0) {
-  uint32 header_size =
-      buffer_data_->data - reinterpret_cast<uint8*>(buffer_data_);
+  uint32_t header_size =
+      buffer_data_->data - reinterpret_cast<uint8_t*>(buffer_data_);
   data_size_ = memory_buffer_size_ - header_size;
 
   DCHECK(buffer_data_);
@@ -61,19 +60,19 @@ PartialCircularBuffer::PartialCircularBuffer(void* buffer,
   }
 }
 
-uint32 PartialCircularBuffer::Read(void* buffer, uint32 buffer_size) {
+uint32_t PartialCircularBuffer::Read(void* buffer, uint32_t buffer_size) {
   DCHECK(buffer_data_);
   if (total_read_ >= buffer_data_->total_written)
     return 0;
 
-  uint8* buffer_uint8 = reinterpret_cast<uint8*>(buffer);
-  uint32 read = 0;
+  uint8_t* buffer_uint8 = reinterpret_cast<uint8_t*>(buffer);
+  uint32_t read = 0;
 
   // Read from beginning part.
   if (position_ < buffer_data_->wrap_position) {
-    uint32 to_wrap_pos = buffer_data_->wrap_position - position_;
-    uint32 to_eow = buffer_data_->total_written - total_read_;
-    uint32 to_read = Min3(buffer_size, to_wrap_pos, to_eow);
+    uint32_t to_wrap_pos = buffer_data_->wrap_position - position_;
+    uint32_t to_eow = buffer_data_->total_written - total_read_;
+    uint32_t to_read = Min3(buffer_size, to_wrap_pos, to_eow);
     memcpy(buffer_uint8, buffer_data_->data + position_, to_read);
     position_ += to_read;
     total_read_ += to_read;
@@ -99,10 +98,10 @@ uint32 PartialCircularBuffer::Read(void* buffer, uint32 buffer_size) {
   // Read from middle part.
   DCHECK_GE(position_, buffer_data_->wrap_position);
   if (position_ >= buffer_data_->end_position) {
-    uint32 remaining_buffer_size = buffer_size - read;
-    uint32 to_eof = data_size_ - position_;
-    uint32 to_eow = buffer_data_->total_written - total_read_;
-    uint32 to_read = Min3(remaining_buffer_size, to_eof, to_eow);
+    uint32_t remaining_buffer_size = buffer_size - read;
+    uint32_t to_eof = data_size_ - position_;
+    uint32_t to_eow = buffer_data_->total_written - total_read_;
+    uint32_t to_read = Min3(remaining_buffer_size, to_eof, to_eow);
     memcpy(buffer_uint8 + read, buffer_data_->data + position_, to_read);
     position_ += to_read;
     total_read_ += to_read;
@@ -124,10 +123,10 @@ uint32 PartialCircularBuffer::Read(void* buffer, uint32 buffer_size) {
   // Read from end part.
   DCHECK_GE(position_, buffer_data_->wrap_position);
   DCHECK_LT(position_, buffer_data_->end_position);
-  uint32 remaining_buffer_size = buffer_size - read;
-  uint32 to_eob = buffer_data_->end_position - position_;
-  uint32 to_eow = buffer_data_->total_written - total_read_;
-  uint32 to_read = Min3(remaining_buffer_size, to_eob, to_eow);
+  uint32_t remaining_buffer_size = buffer_size - read;
+  uint32_t to_eob = buffer_data_->end_position - position_;
+  uint32_t to_eow = buffer_data_->total_written - total_read_;
+  uint32_t to_read = Min3(remaining_buffer_size, to_eob, to_eow);
   memcpy(buffer_uint8 + read, buffer_data_->data + position_, to_read);
   position_ += to_read;
   total_read_ += to_read;
@@ -137,16 +136,16 @@ uint32 PartialCircularBuffer::Read(void* buffer, uint32 buffer_size) {
   return read;
 }
 
-void PartialCircularBuffer::Write(const void* buffer, uint32 buffer_size) {
+void PartialCircularBuffer::Write(const void* buffer, uint32_t buffer_size) {
   DCHECK(buffer_data_);
-  const uint8* input = static_cast<const uint8*>(buffer);
-  uint32 wrap_position = buffer_data_->wrap_position;
-  uint32 cycle_size = data_size_ - wrap_position;
+  const uint8_t* input = static_cast<const uint8_t*>(buffer);
+  uint32_t wrap_position = buffer_data_->wrap_position;
+  uint32_t cycle_size = data_size_ - wrap_position;
 
   // First write the non-wrapping part.
   if (position_ < wrap_position) {
-    uint32 space_left = wrap_position - position_;
-    uint32 write_size = std::min(buffer_size, space_left);
+    uint32_t space_left = wrap_position - position_;
+    uint32_t write_size = std::min(buffer_size, space_left);
     DoWrite(input, write_size);
     input += write_size;
     buffer_size -= write_size;
@@ -154,7 +153,7 @@ void PartialCircularBuffer::Write(const void* buffer, uint32 buffer_size) {
 
   // Skip the part that would overlap.
   if (buffer_size > cycle_size) {
-    uint32 skip = buffer_size - cycle_size;
+    uint32_t skip = buffer_size - cycle_size;
     input += skip;
     buffer_size -= skip;
     position_ = wrap_position + (position_ - wrap_position + skip) % cycle_size;
@@ -164,15 +163,15 @@ void PartialCircularBuffer::Write(const void* buffer, uint32 buffer_size) {
   DoWrite(input, buffer_size);
 }
 
-void PartialCircularBuffer::DoWrite(const uint8* input, uint32 input_size) {
+void PartialCircularBuffer::DoWrite(const uint8_t* input, uint32_t input_size) {
   DCHECK_LT(position_, data_size_);
   buffer_data_->total_written =
       std::min(buffer_data_->total_written + input_size, data_size_);
 
   // Write() skips any overlapping part, so this loop will run at most twice.
   while (input_size > 0) {
-    uint32 space_left = data_size_ - position_;
-    uint32 write_size = std::min(input_size, space_left);
+    uint32_t space_left = data_size_ - position_;
+    uint32_t write_size = std::min(input_size, space_left);
     memcpy(buffer_data_->data + position_, input, write_size);
     input += write_size;
     input_size -= write_size;