incomplete code for mutationobserver and mutationrecord

components/script/dom/mutationobserver.rs

@@ -1,8 +1,37 @@
+use core::ptr::null;
 use dom_struct::dom_struct;
+use dom::bindings::codegen::Bindings::MutationObserverBinding::MutationObserverBinding::MutationObserverMethods;
+use dom::bindings::codegen::Bindings::MutationObserverBinding::MutationObserverInit;
+use dom::bindings::js::Root;
+use dom::bindings::reflector::Reflector;
+use dom::mutationrecord::MutationRecord;
+use dom::node::Node;
 
 #[dom_struct]
 pub struct MutationObserver {
+  reflector_: Reflector,
 }
 
 impl MutationObserver {
 }
+
+impl MutationObserverMethods for MutationObserver {
+
+  //void observe(Node target, optional MutationObserverInit options);
+  fn Observe(&self, target: &Node, options: &MutationObserverInit) {
+	// TODO implement
+  }
+
+
+  //void disconnect();
+  fn Disconnect(&self) {
+	// TODO implement
+  }
+
+  //sequence<MutationRecord> takeRecords();
+  fn TakeRecords(&self) -> Vec<Root<MutationRecord>> {
+      return vec![];
+	//TODO implement
+  }
+
+}

components/script/dom/mutationrecord.rs

@@ -1,8 +1,124 @@
+use core::ptr::null;
 use dom_struct::dom_struct;
+use dom::bindings::codegen::Bindings::MutationRecordBinding::MutationRecordBinding::MutationRecordMethods;
+use dom::bindings::js::{JS, Root};
+use dom::bindings::str::DOMString;
+use dom::bindings::reflector::Reflector;
+use dom::node::Node;
+use dom::nodelist::NodeList;
+use dom::window::Window;
 
 #[dom_struct]
 pub struct MutationRecord {
+  reflector_: Reflector,
+
+//  readonly attribute DOMString record_type;
+  record_type: DOMString,
+
+//  [SameObject]
+//  readonly attribute Node target;
+  target: Root<Node>,
+
+//  [SameObject]
+//  readonly attribute NodeList addedNodes;
+  addedNodes: Root<NodeList>,
+
+//  [SameObject]
+//  readonly attribute NodeList removedNodes;
+  removedNodes: Root<NodeList>,
+
+//  readonly attribute Node? previousSibling;
+  previousSibling: Root<Node>,
+
+//  readonly attribute Node? nextSibling;
+  nextSibling: Root<Node>,
+
+//  readonly attribute DOMString? attributeName;
+  attributeName: DOMString,
+
+//  readonly attribute DOMString? attributeNamespace;
+  attributeNamespace: DOMString,
+
+//  readonly attribute DOMString? oldValue;
+  oldValue: DOMString,
+
 }
 
 impl MutationRecord {
+    fn new(window: &Window, record_type: DOMString, target: Root<Node>) -> Root<MutationRecord> {
+        MutationRecord {
+            reflector_: Reflector::new(),
+            record_type: record_type,
+            target: target,
+            addedNodes: NodeList::empty(window),
+            removedNodes: NodeList::empty(window),
+            previousSibling: None,
+            nextSibling: None,
+            attributeName: None,
+            attributeNamespace: None,
+            oldValue: None,
+        }
+    }
+}
+
+impl MutationRecordMethods for MutationRecord {
+
+  fn Type(&self) -> DOMString {
+      return self.record_type;
+      //return "characterData";
+      //return "childList";
+  }
+
+  fn Target(&self) -> Root<Node> {
+      return self.target;
+  }
+
+  fn AddedNodes(&self) -> Root<NodeList> {
+      return self.addedNodes;
+  }
+
+  fn RemovedNodes(&self) -> Root<NodeList> {
+      return self.removedNodes;
+  }
+
+  fn GetPreviousSibling(&self) -> Option<Root<Node>> {
+      if self.previousSibling.is_null() {
+          return None;
+      } else {
+          return Some(self.previousSibling);
+      }
+  }
+
+  fn GetNextSibling(&self) -> Option<Root<Node>> {
+      if self.nextSibling.is_null() {
+          return None;
+      } else {
+          return Some(self.nextSibling);
+      }
+  }
+
+  fn GetAttributeName(&self) -> Option<DOMString> {
+      if self.attributeName.is_null() {
+          return None;
+      } else {
+          return Some(self.attributeName);
+      }
+  }
+
+  fn GetAttributeNamespace(&self) -> Option<DOMString> {
+      if self.attributeNamespace.is_null() {
+          return None;
+      } else {
+          return Some(self.attributeNamespace);
+      }
+  }
+
+  fn GetOldValue(&self) -> Option<DOMString> {
+      if self.oldValue.is_null() {
+          return None;
+      } else {
+          return Some(self.oldValue);
+      }
+  }
+
 }

components/script/dom/webidls/MutationRecord.webidl

@@ -2,9 +2,12 @@
 interface MutationRecord
  {
   readonly attribute DOMString type;
-  [SameObject] readonly attribute Node target;
-  [SameObject] readonly attribute NodeList addedNodes;
-  [SameObject] readonly attribute NodeList removedNodes;
+  [SameObject]
+  readonly attribute Node target;
+  [SameObject]
+  readonly attribute NodeList addedNodes;
+  [SameObject]
+  readonly attribute NodeList removedNodes;
   readonly attribute Node? previousSibling;
   readonly attribute Node? nextSibling;
   readonly attribute DOMString? attributeName;

components/script/script_thread.rs

@@ -46,6 +46,7 @@ use dom::event::{Event, EventBubbles, EventCancelable};
 use dom::globalscope::GlobalScope;
 use dom::htmlanchorelement::HTMLAnchorElement;
 use dom::htmliframeelement::HTMLIFrameElement;
+use dom::mutationobserver::MutationObserver;
 use dom::node::{Node, NodeDamage, window_from_node};
 use dom::serviceworker::TrustedServiceWorkerAddress;
 use dom::serviceworkerregistration::ServiceWorkerRegistration;
@@ -726,7 +727,7 @@ impl ScriptThread {
 
             microtask_queue: MicrotaskQueue::default(),
 
-	    mutation_observers: Vec![],
+            mutation_observers: vec![],
 
             layout_to_constellation_chan: state.layout_to_constellation_chan,