components/metrics: Add runtime memory leak detector

components/metrics/leak_detector/call_stack_manager.h

+// Copyright 2015 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.
+
+#ifndef COMPONENTS_METRICS_LEAK_DETECTOR_CALL_STACK_MANAGER_H_
+#define COMPONENTS_METRICS_LEAK_DETECTOR_CALL_STACK_MANAGER_H_
+
+#include <stdint.h>
+
+#include "base/containers/hash_tables.h"
+#include "base/macros.h"
+#include "components/metrics/leak_detector/custom_allocator.h"
+#include "components/metrics/leak_detector/stl_allocator.h"
+
+// Summary of structures:
+//
+// struct CallStack:
+//   Represents a unique call stack, defined by its raw call stack (array of
+//   pointers), and hash value. All CallStack objects are owned by class
+//   CallStackManager. Other classes may hold pointers to them but should not
+//   attempt to create or modify any CallStack objects.
+//
+// class CallStackManager:
+//   Creates CallStack objects to represent unique call stacks. Owns all
+//   CallStack objects that it creates, storing them internally.
+//
+//   Returns the call stacks as const pointers because no caller should take
+//   ownership of them and modify or delete them. The lifetime of all CallStack
+//   objects is limited to that of the CallStackManager object that created
+//   them. When the CallStackManager is destroyed, the CallStack objects will be
+//   invalidated. Hence the caller should make sure that it does not use
+//   CallStack objects beyond the lifetime of the CallStackManager that created
+//   them.
+
+namespace metrics {
+namespace leak_detector {
+
+// Struct to represent a call stack.
+struct CallStack {
+  // Call stack as an array of pointers, |stack|. The array length is stored in
+  // |depth|. There is no null terminator.
+  const void** stack;
+  size_t depth;
+
+  // Hash of call stack. It is cached here so that it doesn not have to be
+  // recomputed each time.
+  size_t hash;
+};
+
+// Maintains and owns all unique call stack objects.
+// Not thread-safe.
+class CallStackManager {
+ public:
+  CallStackManager();
+  ~CallStackManager();
+
+  // Returns a CallStack object for a given raw call stack. The first time a
+  // particular raw call stack is passed into this function, it will create a
+  // new CallStack object to hold the raw call stack data, and then return it.
+  // The CallStack object is stored internally.
+  //
+  // On subsequent calls with the same raw call stack, this function will return
+  // the previously created CallStack object.
+  const CallStack* GetCallStack(size_t depth, const void* const stack[]);
+
+  size_t size() const { return call_stacks_.size(); }
+
+ private:
+  // Allocator class for unique call stacks.
+  using CallStackPointerAllocator = STLAllocator<CallStack*, CustomAllocator>;
+
+  // Hash operator for call stack object given as a pointer.
+  // Does not actually compute the hash. Instead, returns the already computed
+  // hash value stored in a CallStack object.
+  struct CallStackPointerStoredHash {
+    size_t operator()(const CallStack* call_stack) const {
+      return call_stack->hash;
+    }
+  };
+
+  // Equality comparator for call stack objects given as pointers. Compares
+  // their stack trace contents.
+  struct CallStackPointerEqual {
+    bool operator()(const CallStack* c1, const CallStack* c2) const;
+  };
+
+  // Holds all call stack objects. Each object is allocated elsewhere and stored
+  // as a pointer because the container may rearrange itself internally.
+  base::hash_set<CallStack*,
+                 CallStackPointerStoredHash,
+                 CallStackPointerEqual,
+                 CallStackPointerAllocator> call_stacks_;
+
+  DISALLOW_COPY_AND_ASSIGN(CallStackManager);
+};
+
+}  // namespace leak_detector
+}  // namespace metrics
+
+#endif  // COMPONENTS_METRICS_LEAK_DETECTOR_CALL_STACK_MANAGER_H_