Remove memory_watcher tool as well as --memory-profile command line flag.

tools/memory_watcher/call_stack.h

Index: tools/memory_watcher/call_stack.h
diff --git a/tools/memory_watcher/call_stack.h b/tools/memory_watcher/call_stack.h
deleted file mode 100644
index 941aad4987e614da171e2b6fa3472fbabe711cab..0000000000000000000000000000000000000000
--- a/tools/memory_watcher/call_stack.h
+++ /dev/null
@@ -1,168 +0,0 @@
-// Copyright (c) 2010 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.
-//
-// Parts of this module come from:
-//  http://www.codeproject.com/KB/applications/visualleakdetector.aspx
-//       by Dan Moulding.
-//  http://www.codeproject.com/KB/threads/StackWalker.aspx
-//       by Jochen Kalmbach
-
-#ifndef TOOLS_MEMORY_WATCHER_CALL_STACK_H_
-#define TOOLS_MEMORY_WATCHER_CALL_STACK_H_
-
-#include <windows.h>
-#include <dbghelp.h>
-#include <functional>
-#include <map>
-#include <string>
-
-#include "base/logging.h"
-#include "base/synchronization/lock.h"
-#include "tools/memory_watcher/memory_watcher.h"
-
-// The CallStack Class
-// A stack where memory has been allocated.
-class CallStack {
- public:
-  // Initialize for tracing CallStacks.
-  static bool Initialize();
-
-  CallStack();
-  virtual ~CallStack() {}
-
-  // Get a hash for this CallStack.
-  // Identical stack traces will have matching hashes.
-  int32 hash() { return hash_; }
-
-  // Get a unique ID for this CallStack.
-  // No two CallStacks will ever have the same ID.  The ID is a monotonically
-  // increasing number.  Newer CallStacks always have larger IDs.
-  int32 id() { return id_; }
-
-  // Retrieves the frame at the specified index.
-  DWORD_PTR frame(int32 index) {
-    DCHECK(index < frame_count_ && index >= 0);
-    return frames_[index];
-  }
-
-  // Compares the CallStack to another CallStack
-  // for equality. Two CallStacks are equal if they are the same size and if
-  // every frame in each is identical to the corresponding frame in the other.
-  bool IsEqual(const CallStack &target);
-
-  typedef std::basic_string<char, std::char_traits<char>,
-                            PrivateHookAllocator<char> > PrivateAllocatorString;
-
-  // Convert the callstack to a string stored in output.
-  void CallStack::ToString(PrivateAllocatorString* output);
-
-  //
-  bool Valid() const { return valid_; }
-
- private:
-  // The maximum number of frames to trace.
-  static const int kMaxTraceFrames = 32;
-
-  // Pushes a frame's program counter onto the CallStack.
-  void AddFrame(DWORD_PTR programcounter);
-
-  // Traces the stack, starting from this function, up to kMaxTraceFrames
-  // frames.
-  bool GetStackTrace();
-
-  // Functions for manipulating the frame list.
-  void ClearFrames();
-
-  // Dynamically load the DbgHelp library and supporting routines that we
-  // will use.
-  static bool LoadDbgHelp();
-
-  static void LockDbgHelp() {
-    dbghelp_lock_.Acquire();
-    active_thread_id_ = GetCurrentThreadId();
-  }
-
-  static void UnlockDbgHelp() {
-    active_thread_id_ = 0;
-    dbghelp_lock_.Release();
-  }
-
-  class AutoDbgHelpLock {
-  public:
-    AutoDbgHelpLock() {
-      CallStack::LockDbgHelp();
-    }
-    ~AutoDbgHelpLock() {
-      CallStack::UnlockDbgHelp();
-    }
-  };
-
-  // Check to see if this thread is already processing a stack.
-  bool LockedRecursionDetected() const;
-
-  // According to http://msdn2.microsoft.com/en-us/library/ms680650(VS.85).aspx
-  // "All DbgHelp functions, such as this one, are single threaded.  Therefore,
-  // calls from more than one thread to this function will likely result in
-  // unexpected behavior or memory corruption.  To avoid this, you must
-  // synchromize all concurrent calls from one thread to this function."
-  //
-  // dbghelp_lock_ is used to serialize access across all calls to the DbgHelp
-  // library.  This may be overly conservative (serializing them all together),
-  // but does guarantee correctness.
-  static base::Lock dbghelp_lock_;
-
-  // Record the fact that dbghelp has been loaded.
-  // Changes to this variable are protected by dbghelp_lock_.
-  // It will only changes once... from false to true.
-  static bool dbghelp_loaded_;
-
-  // To prevent infinite recursion due to unexpected side effects in libraries,
-  // we track the thread_id of the thread currently holding the dbghelp_lock_.
-  // We avoid re-aquiring said lock and return an !valid_ instance when we
-  // detect recursion.
-  static DWORD active_thread_id_;
-
-  int frame_count_;  // Current size (in frames)
-  DWORD_PTR frames_[kMaxTraceFrames];
-  int32 hash_;
-  int32 id_;
-
-  // Indicate is this is a valid stack.
-  // This is false if recursion precluded a real stack generation.
-  bool valid_;
-
-  // Cache ProgramCounter -> Symbol lookups.
-  // This cache is not thread safe.
-  typedef std::map<int32, PrivateAllocatorString, std::less<int32>,
-                   PrivateHookAllocator<int32> > SymbolCache;
-  static SymbolCache* symbol_cache_;
-
-  DISALLOW_COPY_AND_ASSIGN(CallStack);
-};
-
-// An AllocationStack is a type of CallStack which represents a CallStack where
-// memory has been allocated.  This class is also a list item, so that it can
-// be easilly allocated and deallocated from its static singly-linked-list of
-// free instances.
-class AllocationStack : public CallStack {
- public:
-  explicit AllocationStack(int32 size)
-      : next_(NULL), size_(size), CallStack() {}
-
-  // We maintain a freelist of the AllocationStacks.
-  void* operator new(size_t s);
-  void operator delete(void*p);
-
-  int32 size() const { return size_; }
-
- private:
-  AllocationStack* next_;     // Pointer used when on the freelist.
-  int32 size_;                // Size of block allocated.
-  static AllocationStack* freelist_;
-  static base::Lock freelist_lock_;
-
-  DISALLOW_COPY_AND_ASSIGN(AllocationStack);
-};
-
-#endif  // TOOLS_MEMORY_WATCHER_CALL_STACK_H_