diff --git a/servo/components/malloc_size_of/lib.rs b/servo/components/malloc_size_of/lib.rs
index 0e802d386103..413942e43227 100644
--- a/servo/components/malloc_size_of/lib.rs
+++ b/servo/components/malloc_size_of/lib.rs
@@ -39,8 +39,8 @@
 //! - If you need an additional synchronization argument, provide a function
 //!   that is like the standard trait method, but with the extra argument.
 //! - If you need multiple measurements for a type, provide a function named
-//!   `add_size_of_children` that takes a mutable reference to a struct that
-//!   contains the multiple measurement fields.
+//!   `add_size_of` that takes a mutable reference to a struct that contains
+//!   the multiple measurement fields.
 //! - When deep measurement (via `MallocSizeOf`) cannot be implemented for a
 //!   type, shallow measurement (via `MallocShallowSizeOf`) in combination with
 //!   iteration can be a useful substitute.
@@ -64,8 +64,6 @@ extern crate servo_arc;
 extern crate smallbitvec;
 extern crate smallvec;
 
-use servo_arc::Arc;
-use smallvec::{Array, SmallVec};
 use std::hash::{BuildHasher, Hash};
 use std::ops::Range;
 use std::os::raw::c_void;
@@ -244,7 +242,7 @@ impl<T: MallocSizeOf> MallocSizeOf for Vec<T> {
     }
 }
 
-impl<A: Array> MallocShallowSizeOf for SmallVec<A> {
+impl<A: smallvec::Array> MallocShallowSizeOf for smallvec::SmallVec<A> {
     fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
         if self.spilled() {
             unsafe { ops.malloc_size_of(self.as_ptr()) }
@@ -254,8 +252,8 @@ impl<A: Array> MallocShallowSizeOf for SmallVec<A> {
     }
 }
 
-impl<A> MallocSizeOf for SmallVec<A>
-    where A: Array,
+impl<A> MallocSizeOf for smallvec::SmallVec<A>
+    where A: smallvec::Array,
           A::Item: MallocSizeOf
 {
     fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
@@ -348,19 +346,19 @@ impl<K, V, S> MallocSizeOf for hashglobe::hash_map::HashMap<K, V, S>
 //impl<T> !MallocSizeOf for Arc<T> { }
 //impl<T> !MallocShallowSizeOf for Arc<T> { }
 
-impl<T> MallocUnconditionalShallowSizeOf for Arc<T> {
+impl<T> MallocUnconditionalShallowSizeOf for servo_arc::Arc<T> {
     fn unconditional_shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
         unsafe { ops.malloc_size_of(self.heap_ptr()) }
     }
 }
 
-impl<T: MallocSizeOf> MallocUnconditionalSizeOf for Arc<T> {
+impl<T: MallocSizeOf> MallocUnconditionalSizeOf for servo_arc::Arc<T> {
     fn unconditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
         self.unconditional_shallow_size_of(ops) + (**self).size_of(ops)
     }
 }
 
-impl<T> MallocConditionalShallowSizeOf for Arc<T> {
+impl<T> MallocConditionalShallowSizeOf for servo_arc::Arc<T> {
     fn conditional_shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
         if ops.have_seen_ptr(self.heap_ptr()) {
             0
@@ -370,7 +368,7 @@ impl<T> MallocConditionalShallowSizeOf for Arc<T> {
     }
 }
 
-impl<T: MallocSizeOf> MallocConditionalSizeOf for Arc<T> {
+impl<T: MallocSizeOf> MallocConditionalSizeOf for servo_arc::Arc<T> {
     fn conditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
         if ops.have_seen_ptr(self.heap_ptr()) {
             0
diff --git a/servo/components/style/gecko/data.rs b/servo/components/style/gecko/data.rs
index 698a00282d2d..2db087186ad8 100644
--- a/servo/components/style/gecko/data.rs
+++ b/servo/components/style/gecko/data.rs
@@ -181,8 +181,8 @@ impl PerDocumentStyleDataImpl {
     }
 
     /// Measure heap usage.
-    pub fn add_size_of_children(&self, ops: &mut MallocSizeOfOps, sizes: &mut ServoStyleSetSizes) {
-        self.stylist.add_size_of_children(ops, sizes);
+    pub fn add_size_of(&self, ops: &mut MallocSizeOfOps, sizes: &mut ServoStyleSetSizes) {
+        self.stylist.add_size_of(ops, sizes);
     }
 }
 
diff --git a/servo/components/style/stylist.rs b/servo/components/style/stylist.rs
index 5962117fbad0..da17b547d381 100644
--- a/servo/components/style/stylist.rs
+++ b/servo/components/style/stylist.rs
@@ -174,7 +174,7 @@ struct UserAgentCascadeData {
 impl UserAgentCascadeData {
     #[cfg(feature = "gecko")]
     fn add_size_of(&self, ops: &mut MallocSizeOfOps, sizes: &mut ServoStyleSetSizes) {
-        self.cascade_data.add_size_of_children(ops, sizes);
+        self.cascade_data.add_size_of(ops, sizes);
         sizes.mPrecomputedPseudos += self.precomputed_pseudo_element_decls.size_of(ops);
     }
 }
@@ -329,9 +329,9 @@ impl DocumentCascadeData {
 
     /// Measures heap usage.
     #[cfg(feature = "gecko")]
-    pub fn add_size_of_children(&self, ops: &mut MallocSizeOfOps, sizes: &mut ServoStyleSetSizes) {
-        self.user.add_size_of_children(ops, sizes);
-        self.author.add_size_of_children(ops, sizes);
+    pub fn add_size_of(&self, ops: &mut MallocSizeOfOps, sizes: &mut ServoStyleSetSizes) {
+        self.user.add_size_of(ops, sizes);
+        self.author.add_size_of(ops, sizes);
     }
 }
 
@@ -1530,8 +1530,8 @@ impl Stylist {
 
     /// Measures heap usage.
     #[cfg(feature = "gecko")]
-    pub fn add_size_of_children(&self, ops: &mut MallocSizeOfOps, sizes: &mut ServoStyleSetSizes) {
-        self.cascade_data.add_size_of_children(ops, sizes);
+    pub fn add_size_of(&self, ops: &mut MallocSizeOfOps, sizes: &mut ServoStyleSetSizes) {
+        self.cascade_data.add_size_of(ops, sizes);
         sizes.mRuleTree += self.rule_tree.size_of(ops);
 
         // We may measure other fields in the future if DMD says it's worth it.
@@ -2225,7 +2225,7 @@ impl CascadeData {
 
     /// Measures heap usage.
     #[cfg(feature = "gecko")]
-    pub fn add_size_of_children(&self, ops: &mut MallocSizeOfOps, sizes: &mut ServoStyleSetSizes) {
+    pub fn add_size_of(&self, ops: &mut MallocSizeOfOps, sizes: &mut ServoStyleSetSizes) {
         sizes.mElementAndPseudosMaps += self.element_map.size_of(ops);
 
         for elem in self.pseudos_map.iter() {
diff --git a/servo/ports/geckolib/glue.rs b/servo/ports/geckolib/glue.rs
index 18f7afb224ff..a72fd98c194b 100644
--- a/servo/ports/geckolib/glue.rs
+++ b/servo/ports/geckolib/glue.rs
@@ -3781,7 +3781,7 @@ pub extern "C" fn Servo_StyleSet_AddSizeOfExcludingThis(
                                        malloc_enclosing_size_of.unwrap(),
                                        None);
     let sizes = unsafe { sizes.as_mut() }.unwrap();
-    data.add_size_of_children(&mut ops, sizes);
+    data.add_size_of(&mut ops, sizes);
 }
 
 #[no_mangle]