Split getter for mutation_observers() into two methods.

registered_mutation_observers() returns immutable references and does
not init mutation observers.

registered_mutation_observers_mut() lazily initializes raredata if it
does not exist.

Updated code that uses this methods to call appropriate method when
mutation is not necessary.

components/script/dom/mutationobserver.rs

@@ -132,7 +132,12 @@ impl MutationObserver {
 
         // Step 2 & 3
         for node in target.inclusive_ancestors(ShadowIncluding::No) {
-            for registered in &*node.registered_mutation_observers() {
+            let registered = node.registered_mutation_observers();
+            if registered.is_none() {
+                continue;
+            }
+
+            for registered in &*registered.unwrap() {
                 if &*node != target && !registered.options.subtree {
                     continue;
                 }
@@ -297,7 +302,7 @@ impl MutationObserverMethods for MutationObserver {
         // Step 7
         let add_new_observer = {
             let mut replaced = false;
-            for registered in &mut *target.registered_mutation_observers() {
+            for registered in &mut *target.registered_mutation_observers_mut() {
                 if &*registered.observer as *const MutationObserver !=
                     self as *const MutationObserver
                 {

components/script/dom/node.rs

@@ -451,18 +451,25 @@ impl Node {
         cmp & NodeConstants::DOCUMENT_POSITION_PRECEDING != 0
     }
 
-    /// Return all registered mutation observers for this node.
-    /// XXX(ferjm) This should probably be split into two functions,
-    /// `registered_mutation_observers`, which returns an Option or
-    /// an empty slice or something, and doesn't create the rare data,
-    /// and `registered_mutation_observers_mut`, which does lazily
-    /// initialize the raredata.
-    pub fn registered_mutation_observers(&self) -> RefMut<Vec<RegisteredObserver>> {
+    /// Return all registered mutation observers for this node. Lazily initialize the
+    /// raredata if it does not exist.
+    pub fn registered_mutation_observers_mut(&self) -> RefMut<Vec<RegisteredObserver>> {
         RefMut::map(self.ensure_rare_data(), |rare_data| {
             &mut rare_data.mutation_observers
         })
     }
 
+    pub fn registered_mutation_observers(&self) -> Option<Ref<Vec<RegisteredObserver>>> {
+        let rare_data: Ref<_> = self.rare_data.borrow();
+
+        if rare_data.is_none() {
+            return None;
+        }
+        Some(Ref::map(rare_data, |rare_data| {
+            &rare_data.as_ref().unwrap().mutation_observers
+        }))
+    }
+
     /// Add a new mutation observer for a given node.
     pub fn add_mutation_observer(&self, observer: RegisteredObserver) {
         self.ensure_rare_data().mutation_observers.push(observer);