[tracing] Introduce support for userland memory allocators dumps.

base/trace_event/memory_allocator_dump.h

Index: base/trace_event/memory_allocator_dump.h
diff --git a/base/trace_event/memory_allocator_dump.h b/base/trace_event/memory_allocator_dump.h
new file mode 100644
index 0000000000000000000000000000000000000000..37d1761cc8ae01ca7600b0a6bbb656af56be636d
--- /dev/null
+++ b/base/trace_event/memory_allocator_dump.h
@@ -0,0 +1,75 @@
+// 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 BASE_TRACE_EVENT_MEMORY_ALLOCATOR_DUMP_H_
+#define BASE_TRACE_EVENT_MEMORY_ALLOCATOR_DUMP_H_
+
+#include "base/base_export.h"
+#include "base/basictypes.h"
+#include "base/trace_event/memory_allocator_attributes.h"
+#include "base/values.h"
+
+namespace base {
+namespace trace_event {
+
+class MemoryDumpManager;
+class TracedValue;
+
+// Data model for user-land memory allocator dumps.
+class BASE_EXPORT MemoryAllocatorDump {
+ public:
+  MemoryAllocatorDump(const std::string& name, MemoryAllocatorDump* parent);
+  ~MemoryAllocatorDump();
+
+  const std::string& name() const { return name_; }
+  const MemoryAllocatorDump* parent() const { return parent_; }
+
+  void set_physical_size_in_bytes(uint64 value) {
+    physical_size_in_bytes_ = value;
+  }
+  uint64 physical_size_in_bytes() const { return physical_size_in_bytes_; }
+
+  void set_allocated_objects_count(uint64 value) {
+    allocated_objects_count_ = value;
+  }
+  uint64 allocated_objects_count() const { return allocated_objects_count_; }
+
+  void set_allocated_objects_size_in_bytes(uint64 value) {
+    allocated_objects_size_in_bytes_ = value;
+  }
+  uint64 allocated_objects_size_in_bytes() const {
+    return allocated_objects_size_in_bytes_;
+  }
+
+  const DictionaryValue& extra_attributes() const { return extra_attributes_; }

[nduca, 2015/03/12 04:04:10]

i wonder if there's a way to do this that would be less heavy? E.g.
set_extra_attribute(name, Convertible*)?

[Primiano Tucci (use gerrit), 2015/03/13 19:39:07]

Ok, I simplified a lot the extra_attributes logic.
Convertible is IMHO not a really user friendly option (needs to instantiate a
wrapper).
I'd be much more in favor of adding explicit setter getters like this. It's a
bit more work, but they have the great advantage of hiding the memory ownership
problem (the caller doesn't have to allocate anything).
This means that if tomorrow we hit performance / profiling heisenberg problems
we keep the control of the memory management inside the base/ classes, rather
than pushing the burden to the caller. 
WDYT?

+  DictionaryValue& extra_attributes() { return extra_attributes_; }
+
+  // Called at trace generation time to populate the TracedValue.
+  void AsValueInto(TracedValue* value) const;
+
+ protected:
+  friend class MemoryDumpManager;
+  void set_extra_attributes_types(
+      scoped_refptr<MemoryAllocatorDeclaredAttributes> types) {
+    extra_attributes_types_ = types;
+  }
+
+ private:
+  const std::string name_;
+  MemoryAllocatorDump* const parent_;  // Not owned.
+  uint64 physical_size_in_bytes_;
+  uint64 allocated_objects_count_;
+  uint64 allocated_objects_size_in_bytes_;
+  DictionaryValue extra_attributes_;
+
+  // TODO(primiano): remove this once crbug.com/466121 gets fixed.
+  scoped_refptr<MemoryAllocatorDeclaredAttributes> extra_attributes_types_;
+
+  DISALLOW_COPY_AND_ASSIGN(MemoryAllocatorDump);
+};
+
+}  // namespace trace_event
+}  // namespace base
+
+#endif  // BASE_TRACE_EVENT_MEMORY_ALLOCATOR_DUMP_H_