[NOT TO COMMIT!] Replace third_party/tcmalloc/chromium with tcmalloc r136 (the latest).

third_party/tcmalloc/chromium/src/base/stl_allocator.h

 /* Copyright (c) 2006, Google Inc.
  * All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  * 
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 19 matching lines @@
  * ---
  * Author: Maxim Lifantsev
  */
 
 
 #ifndef BASE_STL_ALLOCATOR_H_
 #define BASE_STL_ALLOCATOR_H_
 
 #include <config.h>
 
-#include <stddef.h>   // for std::ptrdiff_t
+#include <stddef.h>   // for ptrdiff_t
 #include <limits>
 
 #include "base/logging.h"
 
 // Generic allocator class for STL objects
 // that uses a given type-less allocator Alloc, which must provide:
 //   static void* Alloc::Allocate(size_t size);
 //   static void Alloc::Free(void* ptr, size_t size);
 //
 // STL_Allocator<T, MyAlloc> provides the same thread-safety
 // guarantees as MyAlloc.
 //
 // Usage example:
 //   set<T, less<T>, STL_Allocator<T, MyAlloc> > my_set;
 // CAVEAT: Parts of the code below are probably specific
 //         to the STL version(s) we are using.
 //         The code is simply lifted from what std::allocator<> provides.
 template <typename T, class Alloc>
 class STL_Allocator {
  public:
   typedef size_t     size_type;
-  typedef std::ptrdiff_t  difference_type;
+  typedef ptrdiff_t  difference_type;
   typedef T*         pointer;
   typedef const T*   const_pointer;
   typedef T&         reference;
   typedef const T&   const_reference;
   typedef T          value_type;
 
   template <class T1> struct rebind {
     typedef STL_Allocator<T1, Alloc> other;
   };
 
   STL_Allocator() { }
   STL_Allocator(const STL_Allocator&) { }
   template <class T1> STL_Allocator(const STL_Allocator<T1, Alloc>&) { }
   ~STL_Allocator() { }
 
   pointer address(reference x) const { return &x; }
   const_pointer address(const_reference x) const { return &x; }
 
   pointer allocate(size_type n, const void* = 0) {
     RAW_DCHECK((n * sizeof(T)) / sizeof(T) == n, "n is too big to allocate");
     return static_cast<T*>(Alloc::Allocate(n * sizeof(T)));
   }
   void deallocate(pointer p, size_type n) { Alloc::Free(p, n * sizeof(T)); }
 
   size_type max_size() const { return size_t(-1) / sizeof(T); }
 
   void construct(pointer p, const T& val) { ::new(p) T(val); }
+  void construct(pointer p) { ::new(p) T(); }
   void destroy(pointer p) { p->~T(); }
 
   // There's no state, so these allocators are always equal
   bool operator==(const STL_Allocator&) const { return true; }
 };
 
 #endif  // BASE_STL_ALLOCATOR_H_