Update the tcmalloc chromium branch to r144 (gperftools 2.0), and merge chromium-specific changes.

third_party/tcmalloc/chromium/src/stack_trace_table.cc

 // Copyright (c) 2009, 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 17 matching lines @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // ---
 // Author: Andrew Fikes
 
 #include <config.h>
 #include "stack_trace_table.h"
 #include <string.h>                     // for NULL, memset
 #include "base/spinlock.h"              // for SpinLockHolder
 #include "common.h"            // for StackTrace
-#include "internal_logging.h"  // for MESSAGE, ASSERT
+#include "internal_logging.h"  // for ASSERT, Log
 #include "page_heap_allocator.h"  // for PageHeapAllocator
 #include "static_vars.h"       // for Static
 
 namespace tcmalloc {
 
 bool StackTraceTable::Bucket::KeyEqual(uintptr_t h,
                                        const StackTrace& t) const {
   const bool eq = (this->hash == h && this->trace.depth == t.depth);
   for (int i = 0; eq && i < t.depth; ++i) {
     if (this->trace.stack[i] != t.stack[i]) {
@@ skipping 37 matching lines @@
     b = b->next;
   }
   if (b != NULL) {
     b->count++;
     b->trace.size += t.size;  // keep cumulative size
   } else {
     depth_total_ += t.depth;
     bucket_total_++;
     b = Static::bucket_allocator()->New();
     if (b == NULL) {
-      MESSAGE("tcmalloc: could not allocate bucket", sizeof(*b));
+      Log(kLog, __FILE__, __LINE__,
+          "tcmalloc: could not allocate bucket", sizeof(*b));
       error_ = true;
     } else {
       b->hash = h;
       b->trace = t;
       b->count = 1;
       b->next = table_[idx];
       table_[idx] = b;
     }
   }
 }
 
 void** StackTraceTable::ReadStackTracesAndClear() {
   if (error_) {
     return NULL;
   }
 
   // Allocate output array
   const int out_len = bucket_total_ * 3 + depth_total_ + 1;
   void** out = new void*[out_len];
   if (out == NULL) {
-    MESSAGE("tcmalloc: allocation failed for stack traces\n",
-            out_len * sizeof(*out));
+    Log(kLog, __FILE__, __LINE__,
+        "tcmalloc: allocation failed for stack traces",
+        out_len * sizeof(*out));
     return NULL;
   }
 
   // Fill output array
   int idx = 0;
   for (int i = 0; i < kHashTableSize; ++i) {
     Bucket* b = table_[i];
     while (b != NULL) {
       out[idx++] = reinterpret_cast<void*>(static_cast<uintptr_t>(b->count));
       out[idx++] = reinterpret_cast<void*>(b->trace.size);  // cumulative size
@@ skipping 19 matching lines @@
       Static::bucket_allocator()->Delete(b);
       b = next;
     }
     table_[i] = NULL;
   }
 
   return out;
 }
 
 }  // namespace tcmalloc