[NOT TO COMMIT!] r109: Diff of the current tcmalloc from the original google-perftools r109.

third_party/tcmalloc/chromium/src/google/malloc_hook.h

 // Copyright (c) 2005, 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 211 matching lines @@
   // memory-allocation call.  It may be useful in memory-limited contexts,
   // to catch allocations that will exceed the limit and take outside
   // actions to increase such a limit.
   typedef MallocHook_PreSbrkHook PreSbrkHook;
   inline static bool AddPreSbrkHook(PreSbrkHook hook) {
     return MallocHook_AddPreSbrkHook(hook);
   }
   inline static bool RemovePreSbrkHook(PreSbrkHook hook) {
     return MallocHook_RemovePreSbrkHook(hook);
   }
-  inline static void InvokePreSbrkHook(ptrdiff_t increment);
+  inline static void InvokePreSbrkHook(std::ptrdiff_t increment);
 
   // The SbrkHook is invoked whenever sbrk is called -- except when
   // the increment is 0.  This is because sbrk(0) is often called
   // to get the top of the memory stack, and is not actually a
   // memory-allocation call.
   typedef MallocHook_SbrkHook SbrkHook;
   inline static bool AddSbrkHook(SbrkHook hook) {
     return MallocHook_AddSbrkHook(hook);
   }
   inline static bool RemoveSbrkHook(SbrkHook hook) {
     return MallocHook_RemoveSbrkHook(hook);
   }
-  inline static void InvokeSbrkHook(const void* result, ptrdiff_t increment);
+  inline static void InvokeSbrkHook(const void* result, std::ptrdiff_t increment);
 
   // Get the current stack trace.  Try to skip all routines up to and
   // and including the caller of MallocHook::Invoke*.
   // Use "skip_count" (similarly to GetStackTrace from stacktrace.h)
   // as a hint about how many routines to skip if better information
   // is not available.
   inline static int GetCallerStackTrace(void** result, int max_depth,
                                         int skip_count) {
     return MallocHook_GetCallerStackTrace(result, max_depth, skip_count);
   }
@@ skipping 75 matching lines @@
   static void InvokeMunmapHookSlow(const void* p, size_t size);
   static bool InvokeMunmapReplacementSlow(const void* p,
                                           size_t size,
                                           int* result);
   static void InvokeMremapHookSlow(const void* result,
                                    const void* old_addr,
                                    size_t old_size,
                                    size_t new_size,
                                    int flags,
                                    const void* new_addr);
-  static void InvokePreSbrkHookSlow(ptrdiff_t increment);
-  static void InvokeSbrkHookSlow(const void* result, ptrdiff_t increment);
+  static void InvokePreSbrkHookSlow(std::ptrdiff_t increment);
+  static void InvokeSbrkHookSlow(const void* result, std::ptrdiff_t increment);
 };
 
 #endif /* _MALLOC_HOOK_H_ */