Replace all uses of the `heapsize` crate with `malloc_size_of`.

Servo currently uses `heapsize`, but Stylo/Gecko use `malloc_size_of`.
`malloc_size_of` is better -- it handles various cases that `heapsize` does not
-- so this patch changes Servo to use `malloc_size_of`.

This patch makes the following changes to the `malloc_size_of` crate.

- Adds `MallocSizeOf` trait implementations for numerous types, some built-in
  (e.g. `VecDeque`), some external and Servo-only (e.g. `string_cache`).

- Makes `enclosing_size_of_op` optional, because vanilla jemalloc doesn't
  support that operation.

- For `HashSet`/`HashMap`, falls back to a computed estimate when
  `enclosing_size_of_op` isn't available.

- Adds an extern "C" `malloc_size_of` function that does the actual heap
  measurement; this is based on the same functions from the `heapsize` crate.

This patch makes the following changes elsewhere.

- Converts all the uses of `heapsize` to instead use `malloc_size_of`.

- Disables the "heapsize"/"heap_size" feature for the external crates that
  provide it.

- Removes the `HeapSizeOf` implementation from `hashglobe`.

- Adds `ignore` annotations to a few `Rc`/`Arc`, because `malloc_size_of`
  doesn't derive those types, unlike `heapsize`.

1 files changed, 10 insertions, 6 deletions

diff --git a/components/script/mem.rs b/components/script/mem.rs
index b40a78ec569..47491359a6d 100644
--- a/components/script/mem.rs
+++ b/components/script/mem.rs
@@ -6,24 +6,28 @@
 
 use dom::bindings::conversions::get_dom_class;
 use dom::bindings::reflector::DomObject;
-use heapsize::{HeapSizeOf, heap_size_of};
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
 use std::os::raw::c_void;
 
 // This is equivalent to measuring a Box<T>, except that DOM objects lose their
 // associated box in order to stash their pointers in a reserved slot of their
 // JS reflector.
 #[allow(unsafe_code)]
-pub fn heap_size_of_self_and_children<T: DomObject + HeapSizeOf>(obj: &T) -> usize {
+pub fn malloc_size_of_including_self<T: DomObject + MallocSizeOf>(
+    ops: &mut MallocSizeOfOps, obj: &T) -> usize
+{
     unsafe {
         let class = get_dom_class(obj.reflector().get_jsobject().get()).unwrap();
-        (class.heap_size_of)(obj as *const T as *const c_void)
+        (class.malloc_size_of)(ops, obj as *const T as *const c_void)
     }
 }
 
-/// Used by codegen to include the pointer to the `HeapSizeOf` implementation of each
+/// Used by codegen to include the pointer to the `MallocSizeOf` implementation of each
 /// IDL interface. This way we don't have to find the most-derived interface of DOM
 /// objects by hand in code.
 #[allow(unsafe_code)]
-pub unsafe fn heap_size_of_raw_self_and_children<T: HeapSizeOf>(obj: *const c_void) -> usize {
-    heap_size_of(obj) + (*(obj as *const T)).heap_size_of_children()
+pub unsafe fn malloc_size_of_including_raw_self<T: MallocSizeOf>(
+    ops: &mut MallocSizeOfOps, obj: *const c_void) -> usize
+{
+    ops.malloc_size_of(obj) + (*(obj as *const T)).size_of(ops)
 }