Replaced ptrdiff_t with std::ptrdiff_t in all files to enable build with gcc-4.6.0.

third_party/tcmalloc/chromium/src/malloc_hook.cc

 // 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 84 matching lines @@
 ATTRIBUTE_WEAK
 extern void InitialMallocHook_MMap(const void* result,
                                    const void* start,
                                    size_t size,
                                    int protection,
                                    int flags,
                                    int fd,
                                    off_t offset);
 
 ATTRIBUTE_WEAK
-extern void InitialMallocHook_PreSbrk(ptrdiff_t increment);
+extern void InitialMallocHook_PreSbrk(std::ptrdiff_t increment);
 
 ATTRIBUTE_WEAK
-extern void InitialMallocHook_Sbrk(const void* result, ptrdiff_t increment);
+extern void InitialMallocHook_Sbrk(const void* result, std::ptrdiff_t increment);
 
 namespace base { namespace internal {
 template<typename PtrT>
 PtrT AtomicPtr<PtrT>::Exchange(PtrT new_val) {
   base::subtle::MemoryBarrier();  // Release semantics.
   // Depending on the system, NoBarrier_AtomicExchange(AtomicWord*)
   // may have been defined to return an AtomicWord, Atomic32, or
   // Atomic64.  We hide that implementation detail here with an
   // explicit cast.  This prevents MSVC 2005, at least, from complaining.
   PtrT old_val = reinterpret_cast<PtrT>(static_cast<AtomicWord>(
@@ skipping 114 matching lines @@
                             const void* start,
                             size_t size,
                             int protection,
                             int flags,
                             int fd,
                             off_t offset) {
   if (MallocHook::GetMmapHook() == &InitialMallocHook_MMap)
     MallocHook::SetMmapHook(NULL);
 }
 
-void InitialMallocHook_PreSbrk(ptrdiff_t increment) {
+void InitialMallocHook_PreSbrk(std::ptrdiff_t increment) {
   if (MallocHook::GetPreSbrkHook() == &InitialMallocHook_PreSbrk)
     MallocHook::SetPreSbrkHook(NULL);
 }
 
-void InitialMallocHook_Sbrk(const void* result, ptrdiff_t increment) {
+void InitialMallocHook_Sbrk(const void* result, std::ptrdiff_t increment) {
   if (MallocHook::GetSbrkHook() == &InitialMallocHook_Sbrk)
     MallocHook::SetSbrkHook(NULL);
 }
 
 DEFINE_ATTRIBUTE_SECTION_VARS(google_malloc);
 DECLARE_ATTRIBUTE_SECTION_VARS(google_malloc);
   // actual functions are in debugallocation.cc or tcmalloc.cc
 DEFINE_ATTRIBUTE_SECTION_VARS(malloc_hook);
 DECLARE_ATTRIBUTE_SECTION_VARS(malloc_hook);
   // actual functions are in this file, malloc_hook.cc, and low_level_alloc.cc
@@ skipping 183 matching lines @@
                int fd, __off64_t offset  ) __THROW
     ATTRIBUTE_SECTION(malloc_hook);
   void* mmap(void *start, size_t length,int prot, int flags,
              int fd, off_t offset) __THROW
     ATTRIBUTE_SECTION(malloc_hook);
   int munmap(void* start, size_t length) __THROW
     ATTRIBUTE_SECTION(malloc_hook);
   void* mremap(void* old_addr, size_t old_size, size_t new_size,
                int flags, ...) __THROW
     ATTRIBUTE_SECTION(malloc_hook);
-  void* sbrk(ptrdiff_t increment) __THROW
+  void* sbrk(std::ptrdiff_t increment) __THROW
     ATTRIBUTE_SECTION(malloc_hook);
 }
 
 extern "C" void* mmap64(void *start, size_t length, int prot, int flags,
                         int fd, __off64_t offset) __THROW {
   MallocHook::InvokePreMmapHook(start, length, prot, flags, fd, offset);
   void *result = do_mmap64(start, length, prot, flags, fd, offset);
   MallocHook::InvokeMmapHook(result, start, length, prot, flags, fd, offset);
   return result;
 }
@@ skipping 22 matching lines @@
   va_start(ap, flags);
   void *new_address = va_arg(ap, void *);
   va_end(ap);
   void* result = sys_mremap(old_addr, old_size, new_size, flags, new_address);
   MallocHook::InvokeMremapHook(result, old_addr, old_size, new_size, flags,
                                new_address);
   return result;
 }
 
 // libc's version:
-extern "C" void* __sbrk(ptrdiff_t increment);
+extern "C" void* __sbrk(std::ptrdiff_t increment);
 
-extern "C" void* sbrk(ptrdiff_t increment) __THROW {
+extern "C" void* sbrk(std::ptrdiff_t increment) __THROW {
   MallocHook::InvokePreSbrkHook(increment);
   void *result = __sbrk(increment);
   MallocHook::InvokeSbrkHook(result, increment);
   return result;
 }
 
 /*static*/void* MallocHook::UnhookedMMap(void *start, size_t length, int prot,
                                          int flags, int fd, off_t offset) {
   return do_mmap64(start, length, prot, flags, fd, offset);
 }
 
 /*static*/int MallocHook::UnhookedMUnmap(void *start, size_t length) {
   return sys_munmap(start, length);
 }
 
 #else   // defined(__linux) &&
         // (defined(__i386__) || defined(__x86_64__) || defined(__PPC__))
 
 /*static*/void* MallocHook::UnhookedMMap(void *start, size_t length, int prot,
                                          int flags, int fd, off_t offset) {
   return mmap(start, length, prot, flags, fd, offset);
 }
 
 /*static*/int MallocHook::UnhookedMUnmap(void *start, size_t length) {
   return munmap(start, length);
 }
 
 #endif  // defined(__linux) &&
         // (defined(__i386__) || defined(__x86_64__) || defined(__PPC__))