Improve memwatch tool....

tools/memory_watcher/memory_watcher.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.
 
 #include <windows.h>
 #include <tlhelp32.h>     // for CreateToolhelp32Snapshot()
 #include <map>
 
 #include "tools/memory_watcher/memory_watcher.h"
 #include "base/file_util.h"
@@ skipping 70 matching lines @@
     fclose(file_);
     file_ = NULL;
     std::wstring tmp_name = ASCIIToWide(file_name_);
     tmp_name += L".tmp";
     file_util::Move(FilePath::FromWStringHack(tmp_name),
                     FilePath::FromWStringHack(ASCIIToWide(file_name_)));
   }
 }
 
 void MemoryWatcher::OnTrack(HANDLE heap, int32 id, int32 size) {
+  // Don't track zeroes.  It's a waste of time.
+  if (size == 0)
+    return;
+
   // AllocationStack overrides new/delete to not allocate
   // from the main heap.
-  AllocationStack* stack = new AllocationStack(size);
+  AllocationStack* stack = new AllocationStack();
   {
-    // Don't track zeroes.  It's a waste of time.
-    if (size == 0) {
-      delete stack;
-      return;
-    }
-
     AutoLock lock(block_map_lock_);
 
     // Ideally, we'd like to verify that the block being added
     // here is not already in our list of tracked blocks.  However,
     // the lookup in our hash table is expensive and slows us too
     // much.  Uncomment this line if you think you need it.
     //DCHECK(block_map_->find(id) == block_map_->end());
 
     (*block_map_)[id] = stack;
 
@@ skipping 11 matching lines @@
 
     block_map_size_ += size;
   }
 
   mem_in_use.Set(block_map_size_);
   mem_in_use_blocks.Increment();
   mem_in_use_allocs.Increment();
 }
 
 void MemoryWatcher::OnUntrack(HANDLE heap, int32 id, int32 size) {
-  DCHECK(size >= 0);
+  DCHECK_GE(size, 0);
 
   // Don't bother with these.
   if (size == 0)
     return;
 
   {
     AutoLock lock(block_map_lock_);
 
     // First, find the block in our block_map.
     CallStackMap::iterator it = block_map_->find(id);
     if (it != block_map_->end()) {
       AllocationStack* stack = it->second;
       CallStackIdMap::iterator id_it = stack_map_->find(stack->hash());
       DCHECK(id_it != stack_map_->end());
       id_it->second.size -= size;
       id_it->second.count--;
-      DCHECK(id_it->second.count >= 0);
+      DCHECK_GE(id_it->second.count, 0);
 
       // If there are no more callstacks with this stack, then we
       // have cleaned up all instances, and can safely delete the
-      // stack pointer in the stack_map.
+      // StackTracker in the stack_map.
       bool safe_to_delete = true;
-      if (id_it->second.count == 0)
-        stack_map_->erase(id_it);
-      else if (id_it->second.stack == stack)
-        safe_to_delete = false;  // we're still using the stack
+      if (id_it->second.count != 0) {
+        // See if our |StackTracker| is also using |stack|.
+        if (id_it->second.stack == stack)
+          safe_to_delete = false;  // We're still using |stack|.
+      } else {
+        // See if we skipped deleting our |StackTracker|'s |stack| earlier.
+        if (id_it->second.stack != stack)
+          delete id_it->second.stack;  // We skipped it earlier.
+        stack_map_->erase(id_it);  // Discard our StackTracker.
+      }
 
       block_map_size_ -= size;
       block_map_->erase(id);
       if (safe_to_delete)
         delete stack;
     } else {
       // Untracked item.  This happens a fair amount, and it is
       // normal.  A lot of time elapses during process startup
       // before the allocation routines are hooked.
     }
@@ skipping 29 matching lines @@
     std::string output;
     stack->ToString(&output);
     fprintf(file_, "%s", output.c_str());
     it++;
   }
   fprintf(file_, "Total Leaks:  %d\n", block_map_->size());
   fprintf(file_, "Total Stacks: %d\n", stack_map_->size());
   fprintf(file_, "Total Bytes:  %d\n", block_map_size_);
   CloseLogFile();
 }