From 1baad884af881cc2626271aec5eef32c640034c0 Mon Sep 17 00:00:00 2001
From: "olafvdspek@gmail.com"
 <olafvdspek@gmail.com@cb39b542-eb2e-2a05-867b-f1791dd5f601>
Date: Thu, 31 May 2012 14:09:19 +0000
Subject: [PATCH] Drop const from size_t

---
 src/base/arena-inl.h | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/base/arena-inl.h b/src/base/arena-inl.h
index 8167304..9dc56c4 100644
--- a/src/base/arena-inl.h
+++ b/src/base/arena-inl.h
@@ -207,13 +207,13 @@ class Gladiator {
   // the arena concept.  If it does pose a problem, flesh out the
   // ArrayGladiator class below.
 
-  void* operator new(const size_t size) {
+  void* operator new(size_t size) {
     void* ret = ::operator new(1 + size);
     static_cast<char *>(ret)[size] = 1;     // mark as heap-allocated
     return ret;
   }
   // the ignored parameter keeps us from stepping on placement new
-  template<class T> void* operator new(const size_t size, const int ignored,
+  template<class T> void* operator new(size_t size, const int ignored,
                                        T* allocator) {
     if (allocator) {
       void* ret = allocator->AllocAligned(1 + size,
@@ -224,7 +224,7 @@ class Gladiator {
       return operator new(size);          // this is the function above
     }
   }
-  void operator delete(void* memory, const size_t size) {
+  void operator delete(void* memory, size_t size) {
     if (static_cast<char*>(memory)[size]) {
       assert (1 == static_cast<char *>(memory)[size]);
       ::operator delete(memory);
@@ -234,7 +234,7 @@ class Gladiator {
       // the Boolean marker flag.
     }
   }
-  template<class T> void operator delete(void* memory, const size_t size,
+  template<class T> void operator delete(void* memory, size_t size,
                                          const int ign, T* allocator) {
     // This "placement delete" can only be called if the constructor
     // throws an exception.
@@ -258,28 +258,28 @@ class ArenaOnlyGladiator {
   // virtual ~ArenaOnlyGladiator() { }
 
   // can't just return NULL here -- compiler gives a warning. :-|
-  void* operator new(const size_t /*size*/) {
+  void* operator new(size_t /*size*/) {
     assert(0);
     return reinterpret_cast<void *>(1);
   }
-  void* operator new[](const size_t /*size*/) {
+  void* operator new[](size_t /*size*/) {
     assert(0);
     return reinterpret_cast<void *>(1);
   }
 
   // the ignored parameter keeps us from stepping on placement new
-  template<class T> void* operator new(const size_t size, const int ignored,
+  template<class T> void* operator new(size_t size, const int ignored,
                                        T* allocator) {
     assert(allocator);
     return allocator->AllocAligned(size, BaseArena::kDefaultAlignment);
   }
-  template<class T> void* operator new[](const size_t size,
+  template<class T> void* operator new[](size_t size,
                                          const int ignored, T* allocator) {
     assert(allocator);
     return allocator->AllocAligned (size, BaseArena::kDefaultAlignment);
   }
-  void operator delete(void* /*memory*/, const size_t /*size*/) { }
-  template<class T> void operator delete(void* memory, const size_t size,
+  void operator delete(void* /*memory*/, size_t /*size*/) { }
+  template<class T> void operator delete(void* memory, size_t size,
                                          const int ign, T* allocator) { }
   void operator delete [](void* /*memory*/) { }
   template<class T> void operator delete(void* memory,
@@ -295,7 +295,7 @@ class ArenaOnlyGladiator {
 
 class ArrayGladiator : public Gladiator {
  public:
-  void * operator new[] (const size_t size) {
+  void * operator new[] (size_t size) {
     const int sizeplus = size + kHeaderSize;
     void * const ret = ::operator new(sizeplus);
     *static_cast<Arena **>(ret) = NULL;  // mark as heap-allocated
@@ -303,7 +303,7 @@ class ArrayGladiator : public Gladiator {
     return ret + kHeaderSize;
   }
   // the ignored parameter keeps us from stepping on placement new
-  template<class T> void * operator new[] (const size_t size,
+  template<class T> void * operator new[] (size_t size,
                                            const int ignored, T * allocator) {
     if (allocator) {
       const int sizeplus = size + kHeaderSize;
@@ -319,7 +319,7 @@ class ArrayGladiator : public Gladiator {
   void operator delete [] (void * memory) {
     memory -= kHeaderSize;
     Arena * const arena = *static_cast<Arena **>(memory);
-    const size_t sizeplus = *static_cast<size_t *>(memory + sizeof(arena));
+    size_t sizeplus = *static_cast<size_t *>(memory + sizeof(arena));
     if (arena) {
       arena->SlowFree(memory, sizeplus);
     } else {
@@ -331,7 +331,7 @@ class ArrayGladiator : public Gladiator {
     // This "placement delete" can only be called if the constructor
     // throws an exception.
     memory -= kHeaderSize;
-    const size_t sizeplus = *static_cast<size_t *>(memory + sizeof(Arena *));
+    size_t sizeplus = *static_cast<size_t *>(memory + sizeof(Arena *));
     if (allocator) {
       allocator->Free(memory, 1 + size);
     } else {