Stop using undocumented _THROW0() macro

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>
@@ skipping 133 matching lines @@
 // temporary file.  The interface is STL inspired but the class does not throw
 // STL exceptions on allocation failure.  Instead it returns NULL.
 // A file allocation will be made if either the requested memory size exceeds
 // |kMaxHeapAllocationSize| or if a heap allocation fails.
 // Allocating the memory as a mapping of a temporary file solves the problem
 // that there might not be enough physical memory and pagefile to support the
 // allocation.  This can happen because these resources are too small, or
 // already committed to other processes.  Provided there is enough disk, the
 // temporary file acts like a pagefile that other processes can't access.
 template<class T>
 class MemoryAllocator {

[tommi (sloooow) - chröme, 2017/03/03 08:32:33]

actually... is there a difference now between the windows and non-windows
implementation?
If not, can we reduce the duplication?

[cblume, 2017/03/06 21:25:45]

It looks like there is a difference.
On Mac & Linux allocation happens on the heap.
On Windows allocation happens on either the heap or a file.
The file acts as a page file that is only available to Chrome.

  public:
   typedef T value_type;
   typedef value_type* pointer;
   typedef value_type& reference;
   typedef const value_type* const_pointer;
   typedef const value_type& const_reference;
   typedef size_t size_type;
   typedef ptrdiff_t difference_type;
 
   // Each allocation is tagged with a single byte so that we know how to
   // deallocate it.
   enum AllocationType {
     HEAP_ALLOCATION,
     FILE_ALLOCATION,
   };
 
   // 5MB is the maximum heap allocation size that we'll attempt.
   // When applying a patch for Chrome 10.X we found that at this
   // threshold there were 17 allocations higher than this threshold
   // (largest at 136MB) 10 allocations just below the threshold and 6362
   // smaller allocations.
   static const size_t kMaxHeapAllocationSize = 1024 * 1024 * 5;
 
   template<class OtherT>
   struct rebind {
     // convert a MemoryAllocator<T> to a MemoryAllocator<OtherT>
     typedef MemoryAllocator<OtherT> other;
   };
 
-  MemoryAllocator() _THROW0() {
-  }
+  MemoryAllocator() {}
 
   // We can't use an explicit constructor here, as dictated by our style guide.
   // The implementation of basic_string in Visual Studio 2010 prevents this.
-  MemoryAllocator(const MemoryAllocator<T>& other) _THROW0() {  // NOLINT
+  MemoryAllocator(const MemoryAllocator<T>& other) {  // NOLINT
   }
 
-  template<class OtherT>
-  MemoryAllocator(const MemoryAllocator<OtherT>& other) _THROW0() {  // NOLINT
+  template <class OtherT>
+  MemoryAllocator(const MemoryAllocator<OtherT>& other) {  // NOLINT
   }
 
   ~MemoryAllocator() {
   }
 
   void deallocate(pointer ptr, size_type size) {
     uint8_t* mem = reinterpret_cast<uint8_t*>(ptr);
     mem -= sizeof(T);
     if (mem[0] == HEAP_ALLOCATION) {
       free(mem);
@@ skipping 41 matching lines @@
   }
 
   void construct(pointer ptr, const T& value) {
     ::new(ptr) T(value);
   }
 
   void destroy(pointer ptr) {
     ptr->~T();
   }
 
-  size_type max_size() const _THROW0() {
+  size_type max_size() const {
     size_type count = static_cast<size_type>(-1) / sizeof(T);
     return (0 < count ? count : 1);
   }
 };
 
 #else  // OS_WIN
 
 // On Mac, Linux, we use a bare bones implementation that only does
 // heap allocations.
 template<class T>
@@ skipping 232 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_