Switch to standard integer types in courgette/.

courgette/memory_allocator.h

 // Copyright (c) 2011 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.
 
 #ifndef COURGETTE_MEMORY_ALLOCATOR_H_
 #define COURGETTE_MEMORY_ALLOCATOR_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <stdlib.h>
 
-#include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/process/memory.h"
 
 #ifndef NDEBUG
 
 // A helper class to track down call sites that are not handling error cases.
 template<class T>
@@ skipping 166 matching lines @@
   }
 
   template<class OtherT>
   MemoryAllocator(const MemoryAllocator<OtherT>& other) _THROW0() {  // NOLINT
   }
 
   ~MemoryAllocator() {
   }
 
   void deallocate(pointer ptr, size_type size) {
-    uint8* mem = reinterpret_cast<uint8*>(ptr);
+    uint8_t* mem = reinterpret_cast<uint8_t*>(ptr);
     mem -= sizeof(T);
     if (mem[0] == HEAP_ALLOCATION) {
       free(mem);
     } else {
-      DCHECK_EQ(static_cast<uint8>(FILE_ALLOCATION), mem[0]);
+      DCHECK_EQ(static_cast<uint8_t>(FILE_ALLOCATION), mem[0]);
       UncheckedDelete(TempMapping::GetMappingFromPtr(mem));
     }
   }
 
   pointer allocate(size_type count) {
     // We use the first byte of each allocation to mark the allocation type.
     // However, so that the allocation is properly aligned, we allocate an
     // extra element and then use the first byte of the first element
     // to mark the allocation type.
     count++;
 
     if (count > max_size())
       return NULL;
 
     size_type bytes = count * sizeof(T);
-    uint8* mem = NULL;
+    uint8_t* mem = NULL;
 
     // First see if we can do this allocation on the heap.
     if (count < kMaxHeapAllocationSize &&
         base::UncheckedMalloc(bytes, reinterpret_cast<void**>(&mem))) {
-      mem[0] = static_cast<uint8>(HEAP_ALLOCATION);
+      mem[0] = static_cast<uint8_t>(HEAP_ALLOCATION);
     } else {
       // Back the allocation with a temp file if either the request exceeds the
       // max heap allocation threshold or the heap allocation failed.
       TempMapping* mapping = UncheckedNew<TempMapping>();
       if (mapping) {
         if (mapping->Initialize(bytes)) {
-          mem = reinterpret_cast<uint8*>(mapping->memory());
-          mem[0] = static_cast<uint8>(FILE_ALLOCATION);
+          mem = reinterpret_cast<uint8_t*>(mapping->memory());
+          mem[0] = static_cast<uint8_t>(FILE_ALLOCATION);
         } else {
           UncheckedDelete(mapping);
         }
       }
     }
     return mem ? reinterpret_cast<pointer>(mem + sizeof(T)) : NULL;
   }
 
   pointer allocate(size_type count, const void* hint) {
     return allocate(count);
@@ skipping 253 matching lines @@
  protected:
   T* buffer_;
   size_t size_;  // how much of the buffer we're using.
   size_t alloc_size_;  // how much space we have allocated.
   Allocator alloc_;
 };
 
 }  // namespace courgette
 
 #endif  // COURGETTE_MEMORY_ALLOCATOR_H_