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

tools/memory_watcher/memory_hook.h

 // 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.  For now,
 // we only add one watcher at a time.
 //
 // TODO(mbelshe):  Support multiple watchers.
 
 #ifndef MEMORY_WATCHER_MEMORY_HOOK_
@@ skipping 17 matching lines @@
   typedef T*        pointer;
   typedef const T*  const_pointer;
   typedef T&        reference;
   typedef const T&  const_reference;
   typedef T         value_type;
 
   PrivateHookAllocator() {}
 
   // Allocate memory for STL.
   pointer allocate(size_type n, const void * = 0) {
-   return reinterpret_cast<T*>(MemoryHook::Alloc(n * sizeof(T)));
+    return reinterpret_cast<T*>(MemoryHook::Alloc(n * sizeof(T)));
   }
 
   // Deallocate memory for STL.
   void deallocate(void* p, size_type) {
     if (p)
       MemoryHook::Free(p);
   }
 
   // Construct the object
   void construct(pointer p, const T& val) {
     new (reinterpret_cast<T*>(p))T(val);
   }
 
   // Destruct an object
   void destroy(pointer p) { p->~T(); }
 
   size_type max_size() const { return size_t(-1); }
 
   template <class U>
   struct rebind { typedef PrivateHookAllocator<U> other; };
 
   template <class U>
   PrivateHookAllocator(const PrivateHookAllocator<U>&) {}
 };
 
 // Classes which monitor memory from these hooks implement
 // the MemoryObserver interface.
 class MemoryObserver {
  public:
+  virtual ~MemoryObserver() {}
+
   // Track a pointer.  Will capture the current StackTrace.
   virtual void OnTrack(HANDLE heap, int32 id, int32 size) = 0;
 
   // Untrack a pointer, removing it from our list.
   virtual void OnUntrack(HANDLE heap, int32 id, int32 size) = 0;
 };
 
 class MemoryHook : MemoryObserver {
  public:
   // Initialize the MemoryHook.  Must be called before
@@ skipping 51 matching lines @@
   // Close our private heap.
   bool CloseHeap();
 
   MemoryObserver* watcher_;
   HANDLE heap_;   // An internal accounting heap.
   static bool hooked_;
   static MemoryHook* global_hook_;
 };
 
 #endif  // MEMORY_WATCHER_MEMORY_HOOK_