Merge google-perftools r109 (the current contents of third_party/tcmalloc/vendor)

third_party/tcmalloc/chromium/src/internal_logging.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 13 matching lines @@
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // ---
 // Sanjay Ghemawat <opensource@google.com>
 
 #include <config.h>
-#include <stdio.h>
-#include <stdarg.h>
+#include "internal_logging.h"
+#include <stdarg.h>                     // for va_end, va_start
+#include <stdio.h>                      // for vsnprintf, va_list, etc
+#include <stdlib.h>                     // for abort
+#include <string.h>                     // for strlen, memcpy
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>    // for write()
 #endif
-#include <string.h>
+
 #include <google/malloc_extension.h>
-#include "internal_logging.h"
+#include "base/logging.h"   // for perftools_vsnprintf
+#include "base/spinlock.h"              // for SpinLockHolder, SpinLock
 
 static const int kLogBufSize = 800;
 
 void TCMalloc_MESSAGE(const char* filename,
                       int line_number,
                       const char* format, ...) {
   char buf[kLogBufSize];
   const int n = snprintf(buf, sizeof(buf), "%s:%d] ", filename, line_number);
   if (n < kLogBufSize) {
     va_list ap;
     va_start(ap, format);
-    vsnprintf(buf + n, kLogBufSize - n, format, ap);
+    perftools_vsnprintf(buf + n, kLogBufSize - n, format, ap);
     va_end(ap);
   }
   write(STDERR_FILENO, buf, strlen(buf));
 }
 
 static const int kStatsBufferSize = 16 << 10;
 static char stats_buffer[kStatsBufferSize] = { 0 };
 
 static void TCMalloc_CRASH_internal(bool dump_stats,
                                     const char* filename,
                                     int line_number,
                                     const char* format, va_list ap) {
   char buf[kLogBufSize];
   const int n = snprintf(buf, sizeof(buf), "%s:%d] ", filename, line_number);
   if (n < kLogBufSize) {
-    vsnprintf(buf + n, kLogBufSize - n, format, ap);
+    perftools_vsnprintf(buf + n, kLogBufSize - n, format, ap);
   }
   write(STDERR_FILENO, buf, strlen(buf));
   if (dump_stats) {
     MallocExtension::instance()->GetStats(stats_buffer, kStatsBufferSize);
     write(STDERR_FILENO, stats_buffer, strlen(stats_buffer));
   }
 
   abort();
 }
 
@@ skipping 12 matching lines @@
   va_list ap;
   va_start(ap, format);
   TCMalloc_CRASH_internal(dump_stats_, file_, line_, format, ap);
   va_end(ap);
 }
 
 void TCMalloc_Printer::printf(const char* format, ...) {
   if (left_ > 0) {
     va_list ap;
     va_start(ap, format);
-    const int r = vsnprintf(buf_, left_, format, ap);
+    const int r = perftools_vsnprintf(buf_, left_, format, ap);
     va_end(ap);
     if (r < 0) {
       // Perhaps an old glibc that returns -1 on truncation?
       left_ = 0;
     } else if (r > left_) {
       // Truncation
       left_ = 0;
     } else {
       left_ -= r;
       buf_ += r;
     }
   }
 }