Remove kuint32max.

base/pickle.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 "base/pickle.h"
 
 #include <stdlib.h>
 
 #include <algorithm>  // for max()
 #include <limits>
@@ skipping 12 matching lines @@
     : payload_(pickle.payload()),
       read_index_(0),
       end_index_(pickle.payload_size()) {
 }
 
 template <typename Type>
 inline bool PickleIterator::ReadBuiltinType(Type* result) {
   const char* read_from = GetReadPointerAndAdvance<Type>();
   if (!read_from)
     return false;
-  if (sizeof(Type) > sizeof(uint32))
+  if (sizeof(Type) > sizeof(uint32_t))
     memcpy(result, read_from, sizeof(*result));
   else
     *result = *reinterpret_cast<const Type*>(read_from);
   return true;
 }
 
 inline void PickleIterator::Advance(size_t size) {
   size_t aligned_size = bits::Align(size, sizeof(uint32_t));
   if (end_index_ - read_index_ < aligned_size) {
     read_index_ = end_index_;
@@ skipping 21 matching lines @@
   }
   const char* current_read_ptr = payload_ + read_index_;
   Advance(num_bytes);
   return current_read_ptr;
 }
 
 inline const char* PickleIterator::GetReadPointerAndAdvance(
     int num_elements,
     size_t size_element) {
   // Check for int32 overflow.
-  int64 num_bytes = static_cast<int64>(num_elements) * size_element;
+  int64_t num_bytes = static_cast<int64_t>(num_elements) * size_element;
   int num_bytes32 = static_cast<int>(num_bytes);
-  if (num_bytes != static_cast<int64>(num_bytes32))
+  if (num_bytes != static_cast<int64_t>(num_bytes32))
     return NULL;
   return GetReadPointerAndAdvance(num_bytes32);
 }
 
 bool PickleIterator::ReadBool(bool* result) {
   return ReadBuiltinType(result);
 }
 
 bool PickleIterator::ReadInt(int* result) {
   return ReadBuiltinType(result);
 }
 
 bool PickleIterator::ReadLong(long* result) {
   return ReadBuiltinType(result);
 }
 
-bool PickleIterator::ReadUInt16(uint16* result) {
+bool PickleIterator::ReadUInt16(uint16_t* result) {
   return ReadBuiltinType(result);
 }
 
-bool PickleIterator::ReadUInt32(uint32* result) {
+bool PickleIterator::ReadUInt32(uint32_t* result) {
   return ReadBuiltinType(result);
 }
 
-bool PickleIterator::ReadInt64(int64* result) {
+bool PickleIterator::ReadInt64(int64_t* result) {
   return ReadBuiltinType(result);
 }
 
-bool PickleIterator::ReadUInt64(uint64* result) {
+bool PickleIterator::ReadUInt64(uint64_t* result) {
   return ReadBuiltinType(result);
 }
 
 bool PickleIterator::ReadSizeT(size_t* result) {
   // Always read size_t as a 64-bit value to ensure compatibility between 32-bit
   // and 64-bit processes.
-  uint64 result_uint64 = 0;
+  uint64_t result_uint64 = 0;
   bool success = ReadBuiltinType(&result_uint64);
   *result = static_cast<size_t>(result_uint64);
   // Fail if the cast above truncates the value.
   return success && (*result == result_uint64);
 }
 
 bool PickleIterator::ReadFloat(float* result) {
   // crbug.com/315213
   // The source data may not be properly aligned, and unaligned float reads
   // cause SIGBUS on some ARM platforms, so force using memcpy to copy the data
@@ skipping 76 matching lines @@
 }
 
 bool PickleIterator::ReadBytes(const char** data, int length) {
   const char* read_from = GetReadPointerAndAdvance(length);
   if (!read_from)
     return false;
   *data = read_from;
   return true;
 }
 
-// Payload is uint32 aligned.
+// Payload is uint32_t aligned.
 
 Pickle::Pickle()
     : header_(NULL),
       header_size_(sizeof(Header)),
       capacity_after_header_(0),
       write_offset_(0) {
   static_assert((Pickle::kPayloadUnit & (Pickle::kPayloadUnit - 1)) == 0,
                 "Pickle::kPayloadUnit must be a power of two");
   Resize(kPayloadUnit);
   header_->payload_size = 0;
 }
 
 Pickle::Pickle(int header_size)
     : header_(NULL),
-      header_size_(bits::Align(header_size, sizeof(uint32))),
+      header_size_(bits::Align(header_size, sizeof(uint32_t))),
       capacity_after_header_(0),
       write_offset_(0) {
   DCHECK_GE(static_cast<size_t>(header_size), sizeof(Header));
   DCHECK_LE(header_size, kPayloadUnit);
   Resize(kPayloadUnit);
   header_->payload_size = 0;
 }
 
 Pickle::Pickle(const char* data, int data_len)
     : header_(reinterpret_cast<Header*>(const_cast<char*>(data))),
       header_size_(0),
       capacity_after_header_(kCapacityReadOnly),
       write_offset_(0) {
   if (data_len >= static_cast<int>(sizeof(Header)))
     header_size_ = data_len - header_->payload_size;
 
   if (header_size_ > static_cast<unsigned int>(data_len))
     header_size_ = 0;
 
-  if (header_size_ != bits::Align(header_size_, sizeof(uint32)))
+  if (header_size_ != bits::Align(header_size_, sizeof(uint32_t)))
     header_size_ = 0;
 
   // If there is anything wrong with the data, we're not going to use it.
   if (!header_size_)
     header_ = NULL;
 }
 
 Pickle::Pickle(const Pickle& other)
     : header_(NULL),
       header_size_(other.header_size_),
@@ skipping 47 matching lines @@
 bool Pickle::WriteData(const char* data, int length) {
   return length >= 0 && WriteInt(length) && WriteBytes(data, length);
 }
 
 bool Pickle::WriteBytes(const void* data, int length) {
   WriteBytesCommon(data, length);
   return true;
 }
 
 void Pickle::Reserve(size_t length) {
-  size_t data_len = bits::Align(length, sizeof(uint32));
+  size_t data_len = bits::Align(length, sizeof(uint32_t));
   DCHECK_GE(data_len, length);
 #ifdef ARCH_CPU_64_BITS
-  DCHECK_LE(data_len, kuint32max);
+  DCHECK_LE(data_len, std::numeric_limits<uint32_t>::max());
 #endif
-  DCHECK_LE(write_offset_, kuint32max - data_len);
+  DCHECK_LE(write_offset_, std::numeric_limits<uint32_t>::max() - data_len);
   size_t new_size = write_offset_ + data_len;
   if (new_size > capacity_after_header_)
     Resize(capacity_after_header_ * 2 + new_size);
 }
 
 void Pickle::Resize(size_t new_capacity) {
   CHECK_NE(capacity_after_header_, kCapacityReadOnly);
   capacity_after_header_ = bits::Align(new_capacity, kPayloadUnit);
   void* p = realloc(header_, GetTotalAllocatedSize());
   CHECK(p);
@@ skipping 18 matching lines @@
     return NULL;
 
   return start + pickle_size;
 }
 
 // static
 bool Pickle::PeekNext(size_t header_size,
                       const char* start,
                       const char* end,
                       size_t* pickle_size) {
-  DCHECK_EQ(header_size, bits::Align(header_size, sizeof(uint32)));
+  DCHECK_EQ(header_size, bits::Align(header_size, sizeof(uint32_t)));
   DCHECK_GE(header_size, sizeof(Header));
   DCHECK_LE(header_size, static_cast<size_t>(kPayloadUnit));
 
   size_t length = static_cast<size_t>(end - start);
   if (length < sizeof(Header))
     return false;
 
   const Header* hdr = reinterpret_cast<const Header*>(start);
   if (length < header_size)
     return false;
@@ skipping 13 matching lines @@
 }
 
 template void Pickle::WriteBytesStatic<2>(const void* data);
 template void Pickle::WriteBytesStatic<4>(const void* data);
 template void Pickle::WriteBytesStatic<8>(const void* data);
 
 inline void Pickle::WriteBytesCommon(const void* data, size_t length) {
   DCHECK_NE(kCapacityReadOnly, capacity_after_header_)
       << "oops: pickle is readonly";
   MSAN_CHECK_MEM_IS_INITIALIZED(data, length);
-  size_t data_len = bits::Align(length, sizeof(uint32));
+  size_t data_len = bits::Align(length, sizeof(uint32_t));
   DCHECK_GE(data_len, length);
 #ifdef ARCH_CPU_64_BITS
-  DCHECK_LE(data_len, kuint32max);
+  DCHECK_LE(data_len, std::numeric_limits<uint32_t>::max());
 #endif
-  DCHECK_LE(write_offset_, kuint32max - data_len);
+  DCHECK_LE(write_offset_, std::numeric_limits<uint32_t>::max() - data_len);
   size_t new_size = write_offset_ + data_len;
   if (new_size > capacity_after_header_) {
     size_t new_capacity = capacity_after_header_ * 2;
     const size_t kPickleHeapAlign = 4096;
     if (new_capacity > kPickleHeapAlign)
       new_capacity = bits::Align(new_capacity, kPickleHeapAlign) - kPayloadUnit;
     Resize(std::max(new_capacity, new_size));
   }
 
   char* write = mutable_payload() + write_offset_;
   memcpy(write, data, length);
   memset(write + length, 0, data_len - length);
-  header_->payload_size = static_cast<uint32>(new_size);
+  header_->payload_size = static_cast<uint32_t>(new_size);
   write_offset_ = new_size;
 }
 
 }  // namespace base