1 files changed, 31 insertions, 26 deletions

diff --git a/components/script/dom/node.rs b/components/script/dom/node.rs
index 811716088b6..2769b7503bc 100644
--- a/components/script/dom/node.rs
+++ b/components/script/dom/node.rs
@@ -159,7 +159,9 @@ bitflags! {
         const SEQUENTIALLY_FOCUSABLE = 0x20,
 
         /// Whether any ancestor is a fragmentation container
-        const CAN_BE_FRAGMENTED = 0x40
+        const CAN_BE_FRAGMENTED = 0x40,
+        #[doc = "Specifies whether this node needs to be dirted when viewport size changed."]
+        const DIRTY_ON_VIEWPORT_SIZE_CHANGE = 0x80
     }
 }
 
@@ -477,19 +479,7 @@ impl Node {
             return
         }
 
-        // 2. Dirty descendants.
-        fn dirty_subtree(node: &Node) {
-            // Stop if this subtree is already dirty.
-            if node.is_dirty() { return }
-
-            node.set_flag(IS_DIRTY | HAS_DIRTY_DESCENDANTS, true);
-
-            for kid in node.children() {
-                dirty_subtree(kid.r());
-            }
-        }
-
-        dirty_subtree(self);
+        self.set_flag(IS_DIRTY, true);
 
         // 4. Dirty ancestors.
         for ancestor in self.ancestors() {
@@ -1297,22 +1287,17 @@ impl TreeIterator {
             depth: 0,
         }
     }
-}
 
-impl Iterator for TreeIterator {
-    type Item = Root<Node>;
-
-    // https://dom.spec.whatwg.org/#concept-tree-order
-    fn next(&mut self) -> Option<Root<Node>> {
+    pub fn next_skipping_children(&mut self) -> Option<Root<Node>> {
         let current = match self.current.take() {
             None => return None,
             Some(current) => current,
         };
-        if let Some(first_child) = current.GetFirstChild() {
-            self.current = Some(first_child);
-            self.depth += 1;
-            return Some(current);
-        };
+
+        self.next_skipping_children_impl(current)
+    }
+
+    fn next_skipping_children_impl(&mut self, current: Root<Node>) -> Option<Root<Node>> {
         for ancestor in current.inclusive_ancestors() {
             if self.depth == 0 {
                 break;
@@ -1329,6 +1314,25 @@ impl Iterator for TreeIterator {
     }
 }
 
+impl Iterator for TreeIterator {
+    type Item = Root<Node>;
+
+    // https://dom.spec.whatwg.org/#concept-tree-order
+    fn next(&mut self) -> Option<Root<Node>> {
+        let current = match self.current.take() {
+            None => return None,
+            Some(current) => current,
+        };
+        if let Some(first_child) = current.GetFirstChild() {
+            self.current = Some(first_child);
+            self.depth += 1;
+            return Some(current);
+        };
+
+        self.next_skipping_children_impl(current)
+    }
+}
+
 /// Specifies whether children must be recursively cloned or not.
 #[derive(Copy, Clone, PartialEq, HeapSizeOf)]
 pub enum CloneChildrenFlag {
@@ -1721,7 +1725,8 @@ impl Node {
                 let document = Document::new(window, None,
                                              Some((*document.url()).clone()),
                                              is_html_doc, None,
-                                             None, DocumentSource::NotFromParser, loader);
+                                             None, DocumentSource::NotFromParser, loader,
+                                             None, None);
                 Root::upcast::<Node>(document)
             },
             NodeTypeId::Element(..) => {