stylo: Cleanup the Gecko bits.

MozReview-Commit-ID: dbVDy1u4vp

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