Add run-time CHECK to smoke-test allocator overrides

base/allocator/allocator_shim_win.cc

 // Copyright (c) 2012 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 <limits.h>
 #include <malloc.h>
 #include <new.h>
 #include <windows.h>
 #include <stddef.h>
 
 // This shim make it possible to perform additional checks on allocations
 // before passing them to the Heap functions.
 
 // Heap functions are stripped from libcmt.lib using the prep_libc.py
 // for each object file stripped, we re-implement them here to allow us to
 // perform additional checks:
 // 1. Enforcing the maximum size that can be allocated to 2Gb.
 // 2. Calling new_handler if malloc fails.
 
 extern "C" {
 // We set this to 1 because part of the CRT uses a check of _crtheap != 0
 // to test whether the CRT has been initialized.  Once we've ripped out
 // the allocators from libcmt, we need to provide this definition so that
 // the rest of the CRT is still usable.
 // heapinit.c
 void* _crtheap = reinterpret_cast<void*>(1);
 }
 
+namespace base {
+namespace allocator {
+bool g_is_win_shim_layer_initialized = false;
+}  // namespace allocator
+}  // namespace base
+
 namespace {
 
 const size_t kWindowsPageSize = 4096;
 const size_t kMaxWindowsAllocation = INT_MAX - kWindowsPageSize;
 int new_mode = 0;
 
 // VS2013 crt uses the process heap as its heap, so we do the same here.
 // See heapinit.c in VS CRT sources.
 bool win_heap_init() {
   // Set the _crtheap global here.  THis allows us to offload most of the
@@ skipping 165 matching lines @@
   return new_ptr;
 }
 
 // heapinit.c
 intptr_t _get_heap_handle() {
   return reinterpret_cast<intptr_t>(_crtheap);
 }
 
 // heapinit.c
 int _heap_init() {
+  base::allocator::g_is_win_shim_layer_initialized = true;
   return win_heap_init() ? 1 : 0;
 }
 
 // heapinit.c
 void _heap_term() {
   win_heap_term();
 }
 
 // calloc.c
 void* calloc(size_t n, size_t elem_size) {
@@ skipping 89 matching lines @@
 void _free_dbg(void* ptr, int) {
   free(ptr);
 }
 
 void* _calloc_dbg(size_t n, size_t size, int, const char*, int) {
   return calloc(n, size);
 }
 #endif  // NDEBUG
 
 }  // extern C