Hook up allocator shim on mac.

base/allocator/allocator_shim_default_dispatch_to_zoned_malloc.cc

+// Copyright 2017 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_default_dispatch_to_zoned_malloc.h"
+
+#include <utility>
+
+#include "base/allocator/allocator_shim.h"
+#include "base/logging.h"
+
+namespace base {
+namespace allocator {
+
+namespace {
+
+// This is the zone that the allocator shim will call to actually perform heap
+// allocations. It should be populated with the original, unintercepted default
+// malloc zone.
+MallocZoneFunctions g_default_zone;
+
+template <class F, class... Args>
+auto CallUnshimmed(F ChromeMallocZone::*m, Args... args)

[Primiano Tucci (use gerrit), 2017/01/28 05:10:02]

This is the part I am really missing here.
I am not talking about the template blackmagic. I just could not figure out why
do you need this fallback CallUnshimmed logic.
You should never end up in a situation where the MallocImpl function is called
but the g_default_zone is null. What am I missing?

[erikchen, 2017/01/31 02:21:22]

This is needed because ThreadHeapUsageTracker::Start is called before
g_default_zone is set.

[DmitrySkiba, 2017/01/31 02:33:37]

Interesting. Originally I added this because in tests some global objects were
allocating memory before InitializeShim() (which was __attribute__(constructor)
at that time).

[Primiano Tucci (use gerrit), 2017/01/31 17:40:05]

Hmm. I can see how that would cause the test to fail. I cannot see how you would
end up inside here in a state where the default zone is replaced (so the
override part is initialized) but this dispatch part is not ready.
ThreadHeapUsageTracker::Start  calls InsertAllocatorDispatch() inserting some
harness.
At this point you should be in a state where there is an element (the test's
dispatcher) in the shim chain, but nothing can't possibly entering the shim
chain, because nothing called InitializeAllocatorShim().  So if the code path
(g_default_zone.malloc == nullptr) is hit, I am still missing something.

If, otherwise, the problem is that the expectations of those test are failing,
the solution should be adding a call to InitializeAllocatorShim() in the test
initialization.

+    -> decltype(std::declval<F>()(nullptr, args...)) {
+  struct _malloc_zone_t* zone = malloc_default_zone();
+  F f = reinterpret_cast<ChromeMallocZone*>(zone)->*m;
+  return f(zone, args...);
+}
+
+void* MallocImpl(const AllocatorDispatch*, size_t size) {
+  if (g_default_zone.malloc)
+    return g_default_zone.malloc(malloc_default_zone(), size);
+  return CallUnshimmed(&ChromeMallocZone::malloc, size);
+}
+
+void* CallocImpl(const AllocatorDispatch*, size_t n, size_t size) {
+  if (g_default_zone.calloc)
+    return g_default_zone.calloc(malloc_default_zone(), n, size);
+  return CallUnshimmed(&ChromeMallocZone::calloc, n, size);
+}
+
+void* MemalignImpl(const AllocatorDispatch*, size_t alignment, size_t size) {
+  if (g_default_zone.memalign)
+    return g_default_zone.memalign(malloc_default_zone(), alignment, size);
+  return CallUnshimmed(&ChromeMallocZone::memalign, alignment, size);
+}
+
+void* ReallocImpl(const AllocatorDispatch*, void* ptr, size_t size) {
+  if (g_default_zone.realloc)
+    return g_default_zone.realloc(malloc_default_zone(), ptr, size);
+  return CallUnshimmed(&ChromeMallocZone::realloc, ptr, size);
+}
+
+void FreeImpl(const AllocatorDispatch*, void* ptr) {
+  if (g_default_zone.free) {
+    g_default_zone.free(malloc_default_zone(), ptr);
+    return;
+  }
+  CallUnshimmed(&ChromeMallocZone::free, ptr);
+}
+
+size_t GetSizeEstimateImpl(const AllocatorDispatch*, void* ptr) {
+  if (g_default_zone.size) {
+    return g_default_zone.size(malloc_default_zone(), ptr);
+  }
+  return CallUnshimmed(&ChromeMallocZone::size, ptr);
+}
+
+unsigned BatchMallocImpl(const AllocatorDispatch* self,
+                         size_t size,
+                         void** results,
+                         unsigned num_requested) {
+  if (g_default_zone.batch_malloc)
+    return g_default_zone.batch_malloc(malloc_default_zone(), size, results,
+                                       num_requested);
+  return CallUnshimmed(&ChromeMallocZone::batch_malloc, size, results,
+                       num_requested);
+}
+
+void BatchFreeImpl(const AllocatorDispatch* self,
+                   void** to_be_freed,
+                   unsigned num_to_be_freed) {
+  if (g_default_zone.batch_free) {
+    g_default_zone.batch_free(malloc_default_zone(), to_be_freed,
+                              num_to_be_freed);
+    return;
+  }
+
+  CallUnshimmed(&ChromeMallocZone::batch_free, to_be_freed, num_to_be_freed);
+}
+
+}  // namespace
+
+void SetDefaultDispatchMallocZoneFunctions(MallocZoneFunctions* functions) {

[Primiano Tucci (use gerrit), 2017/01/28 05:10:02]

this one should be just:
void InitializeDefaultDispatchToMacAllocator() {
   StoreDefaultZoneFunctions(&g_default_zone);
}

[erikchen, 2017/01/31 02:21:22]

Done.

+  g_default_zone.malloc = functions->malloc;
+  g_default_zone.calloc = functions->calloc;
+  g_default_zone.memalign = functions->memalign;
+  g_default_zone.realloc = functions->realloc;
+  g_default_zone.free = functions->free;
+  g_default_zone.size = functions->size;
+  g_default_zone.batch_malloc = functions->batch_malloc;
+  g_default_zone.batch_free = functions->batch_free;
+}
+
+const AllocatorDispatch AllocatorDispatch::default_dispatch = {
+    &MallocImpl,          /* alloc_function */
+    &CallocImpl,          /* alloc_zero_initialized_function */
+    &MemalignImpl,        /* alloc_aligned_function */
+    &ReallocImpl,         /* realloc_function */
+    &FreeImpl,            /* free_function */
+    &GetSizeEstimateImpl, /* get_size_estimate_function */
+    &BatchMallocImpl,     /* batch_malloc_function */
+    &BatchFreeImpl,       /* batch_free_function */
+    nullptr,              /* next */
+};
+
+}  // namespace allocator
+}  // namespace base