Remove tcmalloc when not being used. Restore shim on Windows.

base/allocator/allocator_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <algorithm>   // for min()
 
 #include "base/atomicops.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 262 matching lines @@
   TestLoad<AtomicType>();
 }
 
 static void TestCalloc(size_t n, size_t s, bool ok) {
   char* p = reinterpret_cast<char*>(calloc(n, s));
   if (!ok) {
     EXPECT_EQ(NULL, p) << "calloc(n, s) should not succeed";
   } else {
     EXPECT_NE(reinterpret_cast<void*>(NULL), p) <<
         "calloc(n, s) should succeed";
-    for (int i = 0; i < n*s; i++) {
+    for (size_t i = 0; i < n*s; i++) {
       EXPECT_EQ('\0', p[i]);
     }
     free(p);
   }
 }
 
 // MSVC C4530 complains about exception handler usage when exceptions are
 // disabled.  Temporarily disable that warning so we can test that they are, in
 // fact, disabled.
 #if defined(OS_WIN)
@@ skipping 46 matching lines @@
 
 #if defined(OS_WIN)
 #pragma warning(pop)
 #endif
 
 }  // namespace
 
 //-----------------------------------------------------------------------------
 
 TEST(Atomics, AtomicIncrementWord) {
-  TestAtomicIncrement<AtomicWord>();
+  TestAtomicIncrement<base::subtle::AtomicWord>();
 }
 
 TEST(Atomics, AtomicIncrement32) {
-  TestAtomicIncrement<Atomic32>();
+  TestAtomicIncrement<base::subtle::Atomic32>();
 }
 
 TEST(Atomics, AtomicOpsWord) {
-  TestAtomicIncrement<AtomicWord>();
+  TestAtomicIncrement<base::subtle::AtomicWord>();
 }
 
 TEST(Atomics, AtomicOps32) {
-  TestAtomicIncrement<Atomic32>();
+  TestAtomicIncrement<base::subtle::Atomic32>();
 }
 
 TEST(Allocators, Malloc) {
   // Try allocating data with a bunch of alignments and sizes
   for (int size = 1; size < 1048576; size *= 2) {
     unsigned char* ptr = reinterpret_cast<unsigned char*>(malloc(size));
     CheckAlignment(ptr, 2);  // Should be 2 byte aligned
     Fill(ptr, size);
     EXPECT_TRUE(Valid(ptr, size));
     free(ptr);
@@ skipping 78 matching lines @@
     p[i] = reinterpret_cast<int*>(realloc(p[i], 9000));
   }
   for (int i = 0; i < kNumEntries; i++) {
     sum += p[i][1000];
     free(p[i]);
   }
   EXPECT_EQ(kNumEntries/2 * (kNumEntries - 1), sum);  // assume kNE is even
   free(p);
 }
 
+// tcmalloc uses these semantics but system allocators can return NULL for
+// realloc(ptr, 0).
+#if defined(USE_TCMALLOC)
 TEST(Allocators, ReallocZero) {
   // Test that realloc to zero does not return NULL.
   for (int size = 0; size >= 0; size = NextSize(size)) {
     char* ptr = reinterpret_cast<char*>(malloc(size));
     EXPECT_NE(static_cast<char*>(NULL), ptr);
     ptr = reinterpret_cast<char*>(realloc(ptr, 0));
     EXPECT_NE(static_cast<char*>(NULL), ptr);
     if (ptr)
       free(ptr);
   }
 }
+#endif
 
 #ifdef WIN32
 // Test recalloc
 TEST(Allocators, Recalloc) {
   for (int src_size = 0; src_size >= 0; src_size = NextSize(src_size)) {
     for (int dst_size = 0; dst_size >= 0; dst_size = NextSize(dst_size)) {
       unsigned char* src =
           reinterpret_cast<unsigned char*>(_recalloc(NULL, 1, src_size));
       EXPECT_TRUE(IsZeroed(src, src_size));
       Fill(src, src_size);
@@ skipping 40 matching lines @@
   }
 }
 
 #endif
 
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }