Support running memory watch under vista, plus other tweaks...

tools/memory_watcher/memory_hook.cc

 // Copyright (c) 2006-2008 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.
 
 // Static class for hooking Win32 API routines.
 
 // Some notes about how to hook Memory Allocation Routines in Windows.
 //
 // For our purposes we do not hook the libc routines.  There are two
 // reasons for this.  First, the libc routines all go through HeapAlloc
@@ skipping 199 matching lines @@
 }
 
 static LPVOID WINAPI Perftools_HeapReAlloc(HANDLE hHeap, DWORD dwFlags,
                                            LPVOID lpMem, SIZE_T dwBytes) {
   // Don't call realloc, but instead do a free/malloc.  The problem is that
   // the builtin realloc may either expand a buffer, or it may simply
   // just call free/malloc.  If so, we will already have tracked the new
   // block via Perftools_HeapAlloc.
 
   LPVOID rv = Perftools_HeapAlloc(hHeap, dwFlags, dwBytes);
+  DCHECK_EQ((HEAP_REALLOC_IN_PLACE_ONLY & dwFlags), 0);
 
   // If there was an old buffer, now copy the data to the new buffer.
   if (lpMem != 0) {
     size_t size = HeapSize(hHeap, 0, lpMem);
     if (size > dwBytes)
       size = dwBytes;
     // Note: size could be 0; HeapAlloc does allocate 0 length buffers.
     memcpy(rv, lpMem, size);
     Perftools_HeapFree(hHeap, dwFlags, lpMem);
   }
   return rv;
 }
 
 static LPVOID WINAPI Perftools_VirtualAllocEx(HANDLE process, LPVOID address,
                                               SIZE_T size, DWORD type,
                                               DWORD protect) {
   bool already_committed = false;
   if (address != NULL) {
     MEMORY_BASIC_INFORMATION info;
     CHECK(VirtualQuery(address, &info, sizeof(info)));
-    if (info.State & MEM_COMMIT)
+    if (info.State & MEM_COMMIT) {
       already_committed = true;
+      CHECK(size >= info.RegionSize);
+    }
   }
   bool reserving = (address == NULL) || (type & MEM_RESERVE);
   bool committing = !already_committed && (type & MEM_COMMIT);
 
 
   LPVOID result = patch_VirtualAllocEx()(process, address, size, type,
                                          protect);
   MEMORY_BASIC_INFORMATION info;
   CHECK(VirtualQuery(result, &info, sizeof(info)));
   size = info.RegionSize;
@@ skipping 96 matching lines @@
   HGLOBAL rv = patch_GlobalAlloc()(uFlags, dwBytes);
   return rv;
 }
 
 static HGLOBAL WINAPI Perftools_GlobalFree(HGLOBAL hMem) {
   return patch_GlobalFree()(hMem);
 }
 
 static HGLOBAL WINAPI Perftools_GlobalReAlloc(HGLOBAL hMem, SIZE_T dwBytes,
                                               UINT uFlags) {
+  // TODO(jar): [The following looks like a copy/paste typo from LocalRealloc.]
   // GlobalDiscard is a macro which calls LocalReAlloc with size 0.
   if (dwBytes == 0) {
     return patch_GlobalReAlloc()(hMem, dwBytes, uFlags);
   }
 
   HGLOBAL rv = Perftools_GlobalAlloc(uFlags, dwBytes);
   if (hMem != 0) {
     size_t size = GlobalSize(hMem);
     if (size > dwBytes)
       size = dwBytes;
@@ skipping 140 matching lines @@
     Hook();
 
   DCHECK(global_hook_);
   global_hook_->watcher_ = watcher;
   return true;
 }
 
 bool MemoryHook::UnregisterWatcher(MemoryObserver* watcher) {
   DCHECK(hooked_);
   DCHECK(global_hook_->watcher_ == watcher);
+  // TODO(jar): changing watcher_ here is very racy.  Other threads may (without
+  // a lock) testing, and then calling through this value.  We probably can't
+  // remove this until we are single threaded.
   global_hook_->watcher_ = NULL;
 
   // For now, since there are no more watchers, unhook memory.
   return Unhook();
 }
 
 bool MemoryHook::CreateHeap() {
   // Create a heap for our own memory.
   DCHECK(heap_ == NULL);
   heap_ = HeapCreate(0, 0, 0);
@@ skipping 18 matching lines @@
 }
 
 void MemoryHook::OnUntrack(HANDLE heap, int32 id, int32 size) {
   // Don't notify about allocations to our internal heap.
   if (heap == heap_)
     return;
 
   if (watcher_)
     watcher_->OnUntrack(heap, id, size);
 }