Allocator shim skeleton + Linux impl behind a build flag

base/allocator/allocator_shim_default_dispatch_to_glibc.cc

Index: base/allocator/allocator_shim_default_dispatch_to_glibc.cc
diff --git a/base/allocator/allocator_shim_default_dispatch_to_glibc.cc b/base/allocator/allocator_shim_default_dispatch_to_glibc.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a9f3c5f502cc0f5d06de98494408e577b3d3d0c4
--- /dev/null
+++ b/base/allocator/allocator_shim_default_dispatch_to_glibc.cc
@@ -0,0 +1,52 @@
+// Copyright 2016 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 "base/allocator/allocator_shim.h"
+
+// This translation unit defines a default dispatch for the allocator shim which
+// routes allocations to libc functions.
+// The code here is strongly inspired from tcmalloc's libc_override_glibc.h.
+
+extern "C" {
+void* __libc_malloc(size_t size);
+void* __libc_calloc(size_t n, size_t size);
+void* __libc_realloc(void* address, size_t size);
+void* __libc_memalign(size_t alignment, size_t size);
+void __libc_free(void* ptr);
+}  // extern "C"

[Nico, 2016/03/08 03:08:42]

do we ever want to call glibc instead of tcmalloc?

[Primiano Tucci (use gerrit), 2016/03/08 20:54:05]

That's the case for use_allocator=none.
I am pretty confident there there is some bot/configuration who wants this out
there
(lesson learnt from the previous refactorings: all the build configs that you
expect to not be used are covered by at least one bot you don't know about. All
the configurations that you don't know about are covered by at least one bot
that you don't expect... in the fyi waterfall... 1 week after landing :P)

If I omit this, the base security unittests will fail without the shim when
use_allocator=none.

+
+namespace {
+
+using base::allocator::AllocatorDispatch;
+
+void* GlibcMalloc(size_t size, const AllocatorDispatch*) {
+  return __libc_malloc(size);
+}
+
+void* GlibcCalloc(size_t n, size_t size, const AllocatorDispatch*) {
+  return __libc_calloc(n, size);
+}
+
+void* GlibcRealloc(void* address, size_t size, const AllocatorDispatch*) {
+  return __libc_realloc(address, size);
+}
+
+void* GlibcMemalign(size_t alignment, size_t size, const AllocatorDispatch*) {
+  return __libc_memalign(alignment, size);
+}
+
+void GlibcFree(void* address, const AllocatorDispatch*) {
+  __libc_free(address);
+}
+
+}  // namespace
+
+const AllocatorDispatch AllocatorDispatch::default_dispatch = {
+    &GlibcMalloc,   /* alloc_function */
+    &GlibcCalloc,   /* alloc_zero_initialized_function */
+    &GlibcMemalign, /* alloc_aligned_function */
+    &GlibcRealloc,  /* realloc_function */
+    &GlibcFree,     /* free_function */
+    nullptr,        /* next */
+};