stylo: Cleanup the Gecko bits.

MozReview-Commit-ID: dbVDy1u4vp

components/style/gecko/data.rs

@@ -16,7 +16,7 @@ use gecko_bindings::structs::nsIDocument;
 use gecko_bindings::sugar::ownership::{HasArcFFI, HasBoxFFI, HasFFI, HasSimpleFFI};
 use invalidation::media_queries::{MediaListKey, ToMediaListKey};
 use media_queries::{Device, MediaList};
-use properties::ComputedValuesInner;
+use properties::ComputedValues;
 use shared_lock::{Locked, StylesheetGuards, SharedRwLockReadGuard};
 use stylearc::Arc;
 use stylesheet_set::StylesheetSet;
@@ -188,8 +188,8 @@ impl PerDocumentStyleDataImpl {
     }
 
     /// Get the default computed values for this document.
-    pub fn default_computed_values(&self) -> &ComputedValuesInner {
-        self.stylist.device().default_computed_values()
+    pub fn default_computed_values(&self) -> &Arc<ComputedValues> {
+        self.stylist.device().default_computed_values_arc()
     }
 
     /// Clear the stylist.  This will be a no-op if the stylist is

components/style/gecko/media_queries.rs

@@ -17,9 +17,10 @@ use gecko_bindings::structs::{nsMediaFeature_ValueType, nsMediaFeature_RangeType
 use gecko_bindings::structs::{nsPresContext, RawGeckoPresContextOwned};
 use media_queries::MediaType;
 use parser::ParserContext;
-use properties::{ComputedValuesInner, StyleBuilder};
+use properties::{ComputedValues, StyleBuilder};
 use properties::longhands::font_size;
 use selectors::parser::SelectorParseError;
+use servo_arc::Arc;
 use std::fmt::{self, Write};
 use std::sync::atomic::{AtomicBool, AtomicIsize, Ordering};
 use str::starts_with_ignore_ascii_case;
@@ -36,7 +37,7 @@ pub struct Device {
     /// stylist, and thus the `Device`, so having a raw pres context pointer
     /// here is fine.
     pres_context: RawGeckoPresContextOwned,
-    default_values: ComputedValuesInner,
+    default_values: Arc<ComputedValues>,
     viewport_override: Option<ViewportConstraints>,
     /// The font size of the root element
     /// This is set when computing the style of the root
@@ -61,7 +62,7 @@ impl Device {
         assert!(!pres_context.is_null());
         Device {
             pres_context: pres_context,
-            default_values: ComputedValuesInner::default_values(unsafe { &*pres_context }),
+            default_values: ComputedValues::default_values(unsafe { &*pres_context }),
             viewport_override: None,
             root_font_size: AtomicIsize::new(font_size::get_initial_value().0 as isize), // FIXME(bz): Seems dubious?
             used_root_font_size: AtomicBool::new(false),
@@ -77,7 +78,12 @@ impl Device {
 
     /// Returns the default computed values as a reference, in order to match
     /// Servo.
-    pub fn default_computed_values(&self) -> &ComputedValuesInner {
+    pub fn default_computed_values(&self) -> &ComputedValues {
+        &self.default_values
+    }
+
+    /// Returns the default computed values as an `Arc`.
+    pub fn default_computed_values_arc(&self) -> &Arc<ComputedValues> {
         &self.default_values
     }
 
@@ -101,7 +107,7 @@ impl Device {
     pub fn reset_computed_values(&mut self) {
         // NB: A following stylesheet flush will populate this if appropriate.
         self.viewport_override = None;
-        self.default_values = ComputedValuesInner::default_values(self.pres_context());
+        self.default_values = ComputedValues::default_values(self.pres_context());
         self.used_root_font_size.store(false, Ordering::Relaxed);
     }
 
@@ -620,8 +626,7 @@ impl Expression {
             is_root_element: false,
             device: device,
             inherited_style: default_values,
-            layout_parent_style: default_values,
-            style: StyleBuilder::for_derived_style(default_values),
+            style: StyleBuilder::for_derived_style(device, default_values, None),
             font_metrics_provider: &provider,
             cached_system_font: None,
             in_media_query: true,

components/style/gecko/pseudo_element_definition.mako.rs

@@ -107,7 +107,6 @@ impl PseudoElement {
         }
     }
 
-
     /// Construct a `CSSPseudoElementType` from a pseudo-element
     #[inline]
     pub fn pseudo_type(&self) -> CSSPseudoElementType {
@@ -133,6 +132,21 @@ impl PseudoElement {
         (self.atom().as_ptr(), self.pseudo_type())
     }
 
+    /// Construct a pseudo-element from an `Atom`.
+    #[inline]
+    pub fn from_atom(atom: &Atom) -> Option<Self> {
+        % for pseudo in PSEUDOS:
+            % if pseudo.is_tree_pseudo_element():
+                // We cannot generate ${pseudo_element_variant(pseudo)} from just an atom.
+            % else:
+                if atom == &atom!("${pseudo.value}") {
+                    return Some(${pseudo_element_variant(pseudo)});
+                }
+            % endif
+        % endfor
+        None
+    }
+
     /// Construct a pseudo-element from an anonymous box `Atom`.
     #[inline]
     pub fn from_anon_box_atom(atom: &Atom) -> Option<Self> {

components/style/properties/gecko.mako.rs

@@ -57,6 +57,7 @@ use properties::computed_value_flags::ComputedValueFlags;
 use properties::{longhands, FontComputationData, Importance, LonghandId};
 use properties::{PropertyDeclaration, PropertyDeclarationBlock, PropertyDeclarationId};
 use rule_tree::StrongRuleNode;
+use selector_parser::PseudoElement;
 use std::mem::{forget, uninitialized, transmute, zeroed};
 use std::{cmp, ops, ptr};
 use stylearc::{Arc, RawOffsetArc};
@@ -105,11 +106,37 @@ impl ComputedValues {
             ${style_struct.ident},
             % endfor
         ).to_outer(
-            device,
+            device.pres_context(),
             parent,
             pseudo.map(|p| p.pseudo_info())
         )
     }
+
+    pub fn default_values(pres_context: RawGeckoPresContextBorrowed) -> Arc<Self> {
+        ComputedValuesInner::new(
+            /* custom_properties = */ None,
+            /* writing_mode = */ WritingMode::empty(), // FIXME(bz): This seems dubious
+            FontComputationData::default_font_size_keyword(),
+            ComputedValueFlags::empty(),
+            /* rules = */ None,
+            /* visited_style = */ None,
+            % for style_struct in data.style_structs:
+            style_structs::${style_struct.name}::default(pres_context),
+            % endfor
+        ).to_outer(pres_context, None, None)
+    }
+
+    pub fn pseudo(&self) -> Option<PseudoElement> {
+        use string_cache::Atom;
+
+        let atom = (self.0)._base.mPseudoTag.raw::<structs::nsIAtom>();
+        if atom.is_null() {
+            return None;
+        }
+
+        let atom = Atom::from(atom);
+        PseudoElement::from_atom(&atom)
+    }
 }
 
 impl Drop for ComputedValues {
@@ -145,8 +172,8 @@ impl Clone for ComputedValuesInner {
     }
 }
 
-pub type PseudoInfo = (*mut structs::nsIAtom, structs::CSSPseudoElementType);
-pub type ParentStyleContextInfo<'a> = Option< &'a ComputedValues>;
+type PseudoInfo = (*mut structs::nsIAtom, structs::CSSPseudoElementType);
+type ParentStyleContextInfo<'a> = Option< &'a ComputedValues>;
 
 impl ComputedValuesInner {
     pub fn new(custom_properties: Option<Arc<CustomPropertiesMap>>,
@@ -172,37 +199,28 @@ impl ComputedValuesInner {
         }
     }
 
-    pub fn default_values(pres_context: RawGeckoPresContextBorrowed) -> Self {
-        ComputedValuesInner {
-                custom_properties: None,
-                writing_mode: WritingMode::empty(), // FIXME(bz): This seems dubious
-                font_computation_data: FontComputationData::default_values(),
-                rules: None,
-                visited_style: None,
-                flags: ComputedValueFlags::empty(),
-                % for style_struct in data.style_structs:
-                    ${style_struct.gecko_name}: Arc::into_raw_offset(
-                        style_structs::${style_struct.name}::default(pres_context)
-                    ),
-                % endfor
-        }
-    }
-
-    pub fn to_outer(self, device: &Device, parent: ParentStyleContextInfo,
-                    info: Option<PseudoInfo>) -> Arc<ComputedValues> {
+    fn to_outer(
+        self,
+        pres_context: RawGeckoPresContextBorrowed,
+        parent: ParentStyleContextInfo,
+        info: Option<PseudoInfo>
+    ) -> Arc<ComputedValues> {
         let (tag, ty) = if let Some(info) = info {
             info
         } else {
             (ptr::null_mut(), structs::CSSPseudoElementType::NotPseudo)
         };
 
-        unsafe { self.to_outer_helper(device.pres_context(), parent, ty, tag) }
+        unsafe { self.to_outer_helper(pres_context, parent, ty, tag) }
     }
 
-    unsafe fn to_outer_helper(self, pres_context: bindings::RawGeckoPresContextBorrowed,
-                                    parent: ParentStyleContextInfo,
-                                    pseudo_ty: structs::CSSPseudoElementType,
-                                    pseudo_tag: *mut structs::nsIAtom) -> Arc<ComputedValues> {
+    unsafe fn to_outer_helper(
+        self,
+        pres_context: bindings::RawGeckoPresContextBorrowed,
+        parent: ParentStyleContextInfo,
+        pseudo_ty: structs::CSSPseudoElementType,
+        pseudo_tag: *mut structs::nsIAtom
+    ) -> Arc<ComputedValues> {
         let arc = unsafe {
             let arc: Arc<ComputedValues> = Arc::new(uninitialized());
             bindings::Gecko_ServoStyleContext_Init(&arc.0 as *const _ as *mut _, parent, pres_context,

components/style/properties/properties.mako.rs

@@ -121,10 +121,8 @@ impl FontComputationData {
     }
 
     /// Assigns default values for variables in struct FontComputationData
-    pub fn default_values() -> Self {
-        FontComputationData{
-            font_size_keyword: Some((Default::default(), 1.))
-        }
+    pub fn default_font_size_keyword() -> Option<(longhands::font_size::KeywordSize, f32)> {
+        Some((Default::default(), 1.))
     }
 }
 
@@ -1873,7 +1871,7 @@ pub mod style_structs {
 
 
 #[cfg(feature = "gecko")]
-pub use gecko_properties::{ComputedValues, ComputedValuesInner, ParentStyleContextInfo, PseudoInfo};
+pub use gecko_properties::{ComputedValues, ComputedValuesInner};
 
 #[cfg(feature = "servo")]
 #[cfg_attr(feature = "servo", derive(Clone, Debug))]
@@ -1921,6 +1919,7 @@ pub struct ComputedValues {
     inner: ComputedValuesInner,
 }
 
+#[cfg(feature = "servo")]
 impl ComputedValues {
     /// Create a new refcounted `ComputedValues`
     pub fn new(
@@ -2521,8 +2520,12 @@ impl<'a> StyleBuilder<'a> {
 
     /// Creates a StyleBuilder holding only references to the structs of `s`, in
     /// order to create a derived style.
-    pub fn for_derived_style(device: &'a Device, s: &'a ComputedValues) -> Self {
-        Self::for_inheritance(device, s, s, s.pseudo())
+    pub fn for_derived_style(
+        device: &'a Device,
+        s: &'a ComputedValues,
+        pseudo: Option<<&'a PseudoElement>,
+    ) -> Self {
+        Self::for_inheritance(device, s, s, pseudo)
     }
 
     /// Inherits style from the parent element, accounting for the default

components/style/servo/media_queries.rs

@@ -231,7 +231,7 @@ impl Range<specified::Length> {
             is_root_element: false,
             device: device,
             inherited_style: default_values,
-            style: StyleBuilder::for_derived_style(device, default_values),
+            style: StyleBuilder::for_derived_style(device, default_values, None),
             // Servo doesn't support font metrics
             // A real provider will be needed here once we do; since
             // ch units can exist in media queries.

components/style/stylesheets/viewport_rule.rs

@@ -706,7 +706,7 @@ impl MaybeNew for ViewportConstraints {
             is_root_element: false,
             device: device,
             inherited_style: default_values,
-            style: StyleBuilder::for_derived_style(device, default_values),
+            style: StyleBuilder::for_derived_style(device, default_values, None),
             font_metrics_provider: &provider,
             cached_system_font: None,
             in_media_query: false,