layout: Don't force to overwrite display for pseudo-elements.

components/layout/construct.rs

@@ -1507,11 +1507,13 @@ impl<'a, ConcreteThreadSafeLayoutNode> PostorderNodeMutTraversal<ConcreteThreadS
                 // Pseudo-element.
                 let style = node.style(self.style_context());
                 let display = match node.get_pseudo_element_type() {
-                    PseudoElementType::Normal => display::T::inline,
-                    PseudoElementType::Before(display) => display,
-                    PseudoElementType::After(display) => display,
-                    PseudoElementType::DetailsContent(display) => display,
-                    PseudoElementType::DetailsSummary(display) => display,
+                    PseudoElementType::Normal
+                        => display::T::inline,
+                    PseudoElementType::Before(maybe_display) |
+                    PseudoElementType::After(maybe_display) |
+                    PseudoElementType::DetailsContent(maybe_display) |
+                    PseudoElementType::DetailsSummary(maybe_display)
+                        => maybe_display.unwrap_or(style.get_box().display),
                 };
                 (display, style.get_box().float, style.get_box().position)
             }

components/layout/wrapper.rs

@@ -671,7 +671,7 @@ pub trait ThreadSafeLayoutNode : Clone + Copy + Sized + PartialEq {
 
     /// Creates a new `ThreadSafeLayoutNode` for the same `LayoutNode`
     /// with a different pseudo-element type.
-    fn with_pseudo(&self, pseudo: PseudoElementType<display::T>) -> Self;
+    fn with_pseudo(&self, pseudo: PseudoElementType<Option<display::T>>) -> Self;
 
     /// Converts self into an `OpaqueNode`.
     fn opaque(&self) -> OpaqueNode;
@@ -695,26 +695,28 @@ pub trait ThreadSafeLayoutNode : Clone + Copy + Sized + PartialEq {
     fn as_element(&self) -> Self::ConcreteThreadSafeLayoutElement;
 
     #[inline]
-    fn get_pseudo_element_type(&self) -> PseudoElementType<display::T>;
+    fn get_pseudo_element_type(&self) -> PseudoElementType<Option<display::T>>;
 
     #[inline]
     fn get_before_pseudo(&self) -> Option<Self> {
-        self.borrow_layout_data().unwrap()
+        if self.borrow_layout_data().unwrap()
                .style_data.per_pseudo
-            .get(&PseudoElement::Before)
-            .map(|style| {
-                self.with_pseudo(PseudoElementType::Before(style.get_box().display))
-            })
+               .contains_key(&PseudoElement::Before) {
+            Some(self.with_pseudo(PseudoElementType::Before(None)))
+        } else {
+            None
+        }
     }
 
     #[inline]
     fn get_after_pseudo(&self) -> Option<Self> {
-        self.borrow_layout_data().unwrap()
+        if self.borrow_layout_data().unwrap()
                .style_data.per_pseudo
-            .get(&PseudoElement::After)
-            .map(|style| {
-                self.with_pseudo(PseudoElementType::After(style.get_box().display))
-            })
+               .contains_key(&PseudoElement::After) {
+            Some(self.with_pseudo(PseudoElementType::After(None)))
+        } else {
+            None
+        }
     }
 
     #[inline]
@@ -722,12 +724,7 @@ pub trait ThreadSafeLayoutNode : Clone + Copy + Sized + PartialEq {
         if self.is_element() &&
            self.as_element().get_local_name() == &atom!("details") &&
            self.as_element().get_namespace() == &ns!(html) {
-            self.borrow_layout_data().unwrap()
-                .style_data.per_pseudo
-                .get(&PseudoElement::DetailsSummary)
-                .map(|style| {
-                    self.with_pseudo(PseudoElementType::DetailsSummary(style.get_box().display))
-                })
+            Some(self.with_pseudo(PseudoElementType::DetailsSummary(None)))
         } else {
             None
         }
@@ -735,22 +732,18 @@ pub trait ThreadSafeLayoutNode : Clone + Copy + Sized + PartialEq {
 
     #[inline]
     fn get_details_content_pseudo(&self) -> Option<Self> {
-        if !self.is_element() {
-            return None;
-        }
-
-        let element = self.as_element();
-        if element.get_local_name() != &atom!("details") ||
-           element.get_namespace() != &ns!(html) {
-            return None;
-        }
-
-        let display = if element.get_attr(&ns!(), &atom!("open")).is_some() {
-            display::T::block
+        if self.is_element() &&
+           self.as_element().get_local_name() == &atom!("details") &&
+           self.as_element().get_namespace() == &ns!(html) {
+            let display = if self.as_element().get_attr(&ns!(), &atom!("open")).is_some() {
+                None // Specified by the stylesheet
             } else {
-            display::T::none
+                Some(display::T::none)
             };
             Some(self.with_pseudo(PseudoElementType::DetailsContent(display)))
+        } else {
+            None
+        }
     }
 
     /// Borrows the layout data immutably. Fails on a conflicting borrow.
@@ -933,7 +926,9 @@ pub struct ServoThreadSafeLayoutNode<'ln> {
     /// The wrapped node.
     node: ServoLayoutNode<'ln>,
 
-    pseudo: PseudoElementType<display::T>,
+    /// The pseudo-element type, with (optionally),
+    /// an specified display value to override the stylesheet.
+    pseudo: PseudoElementType<Option<display::T>>,
 }
 
 impl<'a> PartialEq for ServoThreadSafeLayoutNode<'a> {
@@ -983,7 +978,8 @@ impl<'ln> ThreadSafeLayoutNode for ServoThreadSafeLayoutNode<'ln> {
     type ConcreteThreadSafeLayoutElement = ServoThreadSafeLayoutElement<'ln>;
     type ChildrenIterator = ThreadSafeLayoutNodeChildrenIterator<Self>;
 
-    fn with_pseudo(&self, pseudo: PseudoElementType<display::T>) -> ServoThreadSafeLayoutNode<'ln> {
+    fn with_pseudo(&self,
+                   pseudo: PseudoElementType<Option<display::T>>) -> ServoThreadSafeLayoutNode<'ln> {
         ServoThreadSafeLayoutNode {
             node: self.node.clone(),
             pseudo: pseudo,
@@ -1028,7 +1024,7 @@ impl<'ln> ThreadSafeLayoutNode for ServoThreadSafeLayoutNode<'ln> {
         }
     }
 
-    fn get_pseudo_element_type(&self) -> PseudoElementType<display::T> {
+    fn get_pseudo_element_type(&self) -> PseudoElementType<Option<display::T>> {
         self.pseudo
     }
 

resources/servo.css

@@ -54,6 +54,7 @@ details[open]::-servo-details-summary {
 *|*::-servo-details-content {
   margin-left: 40px;
   overflow: hidden;
+  display: block;
 }
 /*
  * Until servo supports svg properly, make sure to at least prevent svg