Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 7739 insertions, 0 deletions

diff --git a/servo/ports/geckolib/glue.rs b/servo/ports/geckolib/glue.rs
new file mode 100644
index 0000000000..713a2e67b7
--- /dev/null
+++ b/servo/ports/geckolib/glue.rs
@@ -0,0 +1,7739 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use super::error_reporter::ErrorReporter;
+use super::stylesheet_loader::{AsyncStylesheetParser, StylesheetLoader};
+use bincode::{deserialize, serialize};
+use cssparser::ToCss as ParserToCss;
+use cssparser::{Parser, ParserInput, SourceLocation, UnicodeRange};
+use dom::{DocumentState, ElementState};
+use malloc_size_of::MallocSizeOfOps;
+use nsstring::{nsCString, nsString};
+use selectors::NthIndexCache;
+use servo_arc::{Arc, ArcBorrow};
+use smallvec::SmallVec;
+use std::collections::BTreeSet;
+use std::fmt::Write;
+use std::iter;
+use std::os::raw::c_void;
+use std::ptr;
+use style::applicable_declarations::ApplicableDeclarationBlock;
+use style::color::mix::ColorInterpolationMethod;
+use style::color::{AbsoluteColor, ColorSpace};
+use style::context::ThreadLocalStyleContext;
+use style::context::{CascadeInputs, QuirksMode, SharedStyleContext, StyleContext};
+use style::counter_style;
+use style::data::{self, ElementStyles};
+use style::dom::{ShowSubtreeData, TDocument, TElement, TNode};
+use style::driver;
+use style::error_reporting::ParseErrorReporter;
+use style::font_face::{self, FontFaceSourceFormat, FontFaceSourceListComponent, Source};
+use style::gecko::arc_types::{
+    LockedCounterStyleRule, LockedCssRules, LockedDeclarationBlock, LockedFontFaceRule,
+    LockedImportRule, LockedKeyframe, LockedKeyframesRule, LockedMediaList, LockedPageRule,
+    LockedStyleRule,
+};
+use style::gecko::data::{
+    AuthorStyles, GeckoStyleSheet, PerDocumentStyleData, PerDocumentStyleDataImpl,
+};
+use style::gecko::restyle_damage::GeckoRestyleDamage;
+use style::gecko::selector_parser::{NonTSPseudoClass, PseudoElement};
+use style::gecko::snapshot_helpers::classes_changed;
+use style::gecko::traversal::RecalcStyleOnly;
+use style::gecko::url;
+use style::gecko::wrapper::{GeckoElement, GeckoNode};
+use style::gecko_bindings::bindings;
+use style::gecko_bindings::bindings::nsACString;
+use style::gecko_bindings::bindings::nsAString;
+use style::gecko_bindings::bindings::Gecko_AddPropertyToSet;
+use style::gecko_bindings::bindings::Gecko_AppendPropertyValuePair;
+use style::gecko_bindings::bindings::Gecko_ConstructFontFeatureValueSet;
+use style::gecko_bindings::bindings::Gecko_ConstructFontPaletteValueSet;
+use style::gecko_bindings::bindings::Gecko_GetOrCreateFinalKeyframe;
+use style::gecko_bindings::bindings::Gecko_GetOrCreateInitialKeyframe;
+use style::gecko_bindings::bindings::Gecko_GetOrCreateKeyframeAtStart;
+use style::gecko_bindings::bindings::Gecko_HaveSeenPtr;
+use style::gecko_bindings::structs;
+use style::gecko_bindings::structs::gfx::FontPaletteValueSet;
+use style::gecko_bindings::structs::gfxFontFeatureValueSet;
+use style::gecko_bindings::structs::ipc::ByteBuf;
+use style::gecko_bindings::structs::nsAtom;
+use style::gecko_bindings::structs::nsCSSCounterDesc;
+use style::gecko_bindings::structs::nsCSSFontDesc;
+use style::gecko_bindings::structs::nsCSSPropertyID;
+use style::gecko_bindings::structs::nsChangeHint;
+use style::gecko_bindings::structs::nsCompatibility;
+use style::gecko_bindings::structs::nsStyleTransformMatrix::MatrixTransformOperator;
+use style::gecko_bindings::structs::nsTArray;
+use style::gecko_bindings::structs::nsresult;
+use style::gecko_bindings::structs::CallerType;
+use style::gecko_bindings::structs::CompositeOperation;
+use style::gecko_bindings::structs::DeclarationBlockMutationClosure;
+use style::gecko_bindings::structs::IterationCompositeOperation;
+use style::gecko_bindings::structs::Loader;
+use style::gecko_bindings::structs::LoaderReusableStyleSheets;
+use style::gecko_bindings::structs::MallocSizeOf as GeckoMallocSizeOf;
+use style::gecko_bindings::structs::OriginFlags;
+use style::gecko_bindings::structs::PropertyValuePair;
+use style::gecko_bindings::structs::PseudoStyleType;
+use style::gecko_bindings::structs::SeenPtrs;
+use style::gecko_bindings::structs::ServoElementSnapshotTable;
+use style::gecko_bindings::structs::ServoStyleSetSizes;
+use style::gecko_bindings::structs::ServoTraversalFlags;
+use style::gecko_bindings::structs::SheetLoadData;
+use style::gecko_bindings::structs::SheetLoadDataHolder;
+use style::gecko_bindings::structs::SheetParsingMode;
+use style::gecko_bindings::structs::StyleRuleInclusion;
+use style::gecko_bindings::structs::StyleSheet as DomStyleSheet;
+use style::gecko_bindings::structs::URLExtraData;
+use style::gecko_bindings::structs::{nsINode as RawGeckoNode, Element as RawGeckoElement};
+use style::gecko_bindings::sugar::ownership::Strong;
+use style::gecko_bindings::sugar::refptr::RefPtr;
+use style::global_style_data::{
+    GlobalStyleData, StyleThreadPool, GLOBAL_STYLE_DATA, STYLE_THREAD_POOL,
+};
+use style::invalidation::element::restyle_hints::RestyleHint;
+use style::invalidation::stylesheets::RuleChangeKind;
+use style::media_queries::MediaList;
+use style::parser::{self, Parse, ParserContext};
+use style::properties::animated_properties::{AnimationValue, AnimationValueMap};
+use style::properties::{parse_one_declaration_into, parse_style_attribute};
+use style::properties::{ComputedValues, CountedUnknownProperty, Importance, NonCustomPropertyId};
+use style::properties::{LonghandId, LonghandIdSet, PropertyDeclarationBlock, PropertyId};
+use style::properties::{PropertyDeclarationId, ShorthandId};
+use style::properties::{SourcePropertyDeclaration, StyleBuilder};
+use style::properties_and_values::rule::Inherits as PropertyInherits;
+use style::rule_cache::RuleCacheConditions;
+use style::rule_tree::{CascadeLevel, StrongRuleNode};
+use style::selector_parser::PseudoElementCascadeType;
+use style::shared_lock::{
+    Locked, SharedRwLock, SharedRwLockReadGuard, StylesheetGuards, ToCssWithGuard,
+};
+use style::string_cache::{Atom, WeakAtom};
+use style::style_adjuster::StyleAdjuster;
+use style::stylesheets::container_rule::ContainerSizeQuery;
+use style::stylesheets::import_rule::{ImportLayer, ImportSheet};
+use style::stylesheets::keyframes_rule::{Keyframe, KeyframeSelector, KeyframesStepValue};
+use style::stylesheets::layer_rule::LayerOrder;
+use style::stylesheets::supports_rule::parse_condition_or_declaration;
+use style::stylesheets::{
+    AllowImportRules, ContainerRule, CounterStyleRule, CssRule, CssRuleType, CssRules,
+    CssRulesHelpers, DocumentRule, FontFaceRule, FontFeatureValuesRule, FontPaletteValuesRule,
+    ImportRule, KeyframesRule, LayerBlockRule, LayerStatementRule, MediaRule, NamespaceRule,
+    Origin, OriginSet, PageRule, PropertyRule, SanitizationData, SanitizationKind, StyleRule,
+    StylesheetContents, StylesheetLoader as StyleStylesheetLoader, SupportsRule, UrlExtraData,
+};
+use style::stylist::{add_size_of_ua_cache, AuthorStylesEnabled, RuleInclusion, Stylist};
+use style::thread_state;
+use style::traversal::resolve_style;
+use style::traversal::DomTraversal;
+use style::traversal_flags::{self, TraversalFlags};
+use style::use_counters::UseCounters;
+use style::values::animated::{Animate, Procedure, ToAnimatedZero};
+use style::values::computed::easing::ComputedTimingFunction;
+use style::values::computed::font::{
+    FontFamily, FontFamilyList, FontStretch, FontStyle, FontWeight, GenericFontFamily,
+};
+use style::values::computed::{self, Context, ToComputedValue};
+use style::values::distance::ComputeSquaredDistance;
+use style::values::generics::easing::BeforeFlag;
+use style::values::specified::gecko::IntersectionObserverRootMargin;
+use style::values::specified::source_size_list::SourceSizeList;
+use style::values::specified::{AbsoluteLength, NoCalcLength};
+use style::values::{specified, AtomIdent, CustomIdent, KeyframesName};
+use style_traits::{CssWriter, ParseError, ParsingMode, ToCss};
+use thin_vec::ThinVec;
+use to_shmem::SharedMemoryBuilder;
+
+trait ClosureHelper {
+    fn invoke(&self, property_id: Option<NonCustomPropertyId>);
+}
+
+impl ClosureHelper for DeclarationBlockMutationClosure {
+    #[inline]
+    fn invoke(&self, property_id: Option<NonCustomPropertyId>) {
+        if let Some(function) = self.function.as_ref() {
+            let gecko_prop_id = match property_id {
+                Some(p) => p.to_nscsspropertyid(),
+                None => nsCSSPropertyID::eCSSPropertyExtra_variable,
+            };
+            unsafe { function(self.data, gecko_prop_id) }
+        }
+    }
+}
+
+/*
+ * For Gecko->Servo function calls, we need to redeclare the same signature that was declared in
+ * the C header in Gecko. In order to catch accidental mismatches, we run rust-bindgen against
+ * those signatures as well, giving us a second declaration of all the Servo_* functions in this
+ * crate. If there's a mismatch, LLVM will assert and abort, which is a rather awful thing to
+ * depend on but good enough for our purposes.
+ */
+
+// A dummy url data for where we don't pass url data in.
+static mut DUMMY_URL_DATA: *mut URLExtraData = 0 as *mut _;
+static mut DUMMY_CHROME_URL_DATA: *mut URLExtraData = 0 as *mut _;
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_Initialize(
+    dummy_url_data: *mut URLExtraData,
+    dummy_chrome_url_data: *mut URLExtraData,
+) {
+    use style::gecko_bindings::sugar::origin_flags;
+
+    // Pretend that we're a Servo Layout thread, to make some assertions happy.
+    thread_state::initialize(thread_state::ThreadState::LAYOUT);
+
+    // Perform some debug-only runtime assertions.
+    origin_flags::assert_flags_match();
+    parser::assert_parsing_mode_match();
+    traversal_flags::assert_traversal_flags_match();
+    specified::font::assert_variant_east_asian_matches();
+    specified::font::assert_variant_ligatures_matches();
+
+    DUMMY_URL_DATA = dummy_url_data;
+    DUMMY_CHROME_URL_DATA = dummy_chrome_url_data;
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_Shutdown() {
+    DUMMY_URL_DATA = ptr::null_mut();
+    DUMMY_CHROME_URL_DATA = ptr::null_mut();
+    Stylist::shutdown();
+    url::shutdown();
+}
+
+#[inline(always)]
+unsafe fn dummy_url_data() -> &'static UrlExtraData {
+    UrlExtraData::from_ptr_ref(&DUMMY_URL_DATA)
+}
+
+#[allow(dead_code)]
+fn is_main_thread() -> bool {
+    unsafe { bindings::Gecko_IsMainThread() }
+}
+
+#[allow(dead_code)]
+fn is_dom_worker_thread() -> bool {
+    unsafe { bindings::Gecko_IsDOMWorkerThread() }
+}
+
+thread_local! {
+    /// Thread-local style data for DOM workers
+    static DOM_WORKER_RWLOCK: SharedRwLock = SharedRwLock::new();
+}
+
+#[allow(dead_code)]
+fn is_in_servo_traversal() -> bool {
+    unsafe { bindings::Gecko_IsInServoTraversal() }
+}
+
+fn create_shared_context<'a>(
+    global_style_data: &GlobalStyleData,
+    guard: &'a SharedRwLockReadGuard,
+    stylist: &'a Stylist,
+    traversal_flags: TraversalFlags,
+    snapshot_map: &'a ServoElementSnapshotTable,
+) -> SharedStyleContext<'a> {
+    SharedStyleContext {
+        stylist: &stylist,
+        visited_styles_enabled: stylist.device().visited_styles_enabled(),
+        options: global_style_data.options.clone(),
+        guards: StylesheetGuards::same(guard),
+        current_time_for_animations: 0.0, // Unused for Gecko, at least for now.
+        traversal_flags,
+        snapshot_map,
+    }
+}
+
+fn traverse_subtree(
+    element: GeckoElement,
+    global_style_data: &GlobalStyleData,
+    per_doc_data: &PerDocumentStyleDataImpl,
+    guard: &SharedRwLockReadGuard,
+    traversal_flags: TraversalFlags,
+    snapshots: &ServoElementSnapshotTable,
+) {
+    let shared_style_context = create_shared_context(
+        &global_style_data,
+        &guard,
+        &per_doc_data.stylist,
+        traversal_flags,
+        snapshots,
+    );
+
+    let token = RecalcStyleOnly::pre_traverse(element, &shared_style_context);
+
+    if !token.should_traverse() {
+        return;
+    }
+
+    debug!("Traversing subtree from {:?}", element);
+
+    let thread_pool_holder = &*STYLE_THREAD_POOL;
+    let pool;
+    let thread_pool = if traversal_flags.contains(TraversalFlags::ParallelTraversal) {
+        pool = thread_pool_holder.pool();
+        pool.as_ref()
+    } else {
+        None
+    };
+
+    let traversal = RecalcStyleOnly::new(shared_style_context);
+    driver::traverse_dom(&traversal, token, thread_pool);
+}
+
+/// Traverses the subtree rooted at `root` for restyling.
+///
+/// Returns whether the root was restyled. Whether anything else was restyled or
+/// not can be inferred from the dirty bits in the rest of the tree.
+#[no_mangle]
+pub extern "C" fn Servo_TraverseSubtree(
+    root: &RawGeckoElement,
+    raw_data: &PerDocumentStyleData,
+    snapshots: *const ServoElementSnapshotTable,
+    raw_flags: ServoTraversalFlags,
+) -> bool {
+    let traversal_flags = TraversalFlags::from_bits_retain(raw_flags);
+    debug_assert!(!snapshots.is_null());
+
+    let element = GeckoElement(root);
+
+    debug!("Servo_TraverseSubtree (flags={:?})", traversal_flags);
+    debug!("{:?}", ShowSubtreeData(element.as_node()));
+
+    if cfg!(debug_assertions) {
+        if let Some(parent) = element.traversal_parent() {
+            let data = parent
+                .borrow_data()
+                .expect("Styling element with unstyled parent");
+            assert!(
+                !data.styles.is_display_none(),
+                "Styling element with display: none parent"
+            );
+        }
+    }
+
+    let needs_animation_only_restyle =
+        element.has_animation_only_dirty_descendants() || element.has_animation_restyle_hints();
+
+    let per_doc_data = raw_data.borrow();
+    debug_assert!(!per_doc_data.stylist.stylesheets_have_changed());
+
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+
+    let was_initial_style = !element.has_data();
+
+    if needs_animation_only_restyle {
+        debug!(
+            "Servo_TraverseSubtree doing animation-only restyle (aodd={})",
+            element.has_animation_only_dirty_descendants()
+        );
+        traverse_subtree(
+            element,
+            &global_style_data,
+            &per_doc_data,
+            &guard,
+            traversal_flags | TraversalFlags::AnimationOnly,
+            unsafe { &*snapshots },
+        );
+    }
+
+    traverse_subtree(
+        element,
+        &global_style_data,
+        &per_doc_data,
+        &guard,
+        traversal_flags,
+        unsafe { &*snapshots },
+    );
+
+    debug!(
+        "Servo_TraverseSubtree complete (dd={}, aodd={}, lfcd={}, lfc={}, data={:?})",
+        element.has_dirty_descendants(),
+        element.has_animation_only_dirty_descendants(),
+        element.descendants_need_frames(),
+        element.needs_frame(),
+        element.borrow_data().unwrap()
+    );
+
+    if was_initial_style {
+        debug_assert!(!element.borrow_data().unwrap().contains_restyle_data());
+        false
+    } else {
+        let element_was_restyled = element.borrow_data().unwrap().contains_restyle_data();
+        element_was_restyled
+    }
+}
+
+/// Checks whether the rule tree has crossed its threshold for unused nodes, and
+/// if so, frees them.
+#[no_mangle]
+pub extern "C" fn Servo_MaybeGCRuleTree(raw_data: &PerDocumentStyleData) {
+    let per_doc_data = raw_data.borrow_mut();
+    per_doc_data.stylist.rule_tree().maybe_gc();
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AnimationValues_Interpolate(
+    from: &AnimationValue,
+    to: &AnimationValue,
+    progress: f64,
+) -> Strong<AnimationValue> {
+    if let Ok(value) = from.animate(to, Procedure::Interpolate { progress }) {
+        Arc::new(value).into()
+    } else {
+        Strong::null()
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AnimationValues_IsInterpolable(
+    from: &AnimationValue,
+    to: &AnimationValue,
+) -> bool {
+    from.animate(to, Procedure::Interpolate { progress: 0.5 })
+        .is_ok()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AnimationValues_Add(
+    a: &AnimationValue,
+    b: &AnimationValue,
+) -> Strong<AnimationValue> {
+    if let Ok(value) = a.animate(b, Procedure::Add) {
+        Arc::new(value).into()
+    } else {
+        Strong::null()
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AnimationValues_Accumulate(
+    a: &AnimationValue,
+    b: &AnimationValue,
+    count: u64,
+) -> Strong<AnimationValue> {
+    if let Ok(value) = a.animate(b, Procedure::Accumulate { count }) {
+        Arc::new(value).into()
+    } else {
+        Strong::null()
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AnimationValues_GetZeroValue(
+    value_to_match: &AnimationValue,
+) -> Strong<AnimationValue> {
+    if let Ok(zero_value) = value_to_match.to_animated_zero() {
+        Arc::new(zero_value).into()
+    } else {
+        Strong::null()
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AnimationValues_ComputeDistance(
+    from: &AnimationValue,
+    to: &AnimationValue,
+) -> f64 {
+    // If compute_squared_distance() failed, this function will return negative value
+    // in order to check whether we support the specified paced animation values.
+    from.compute_squared_distance(to).map_or(-1.0, |d| d.sqrt())
+}
+
+/// Compute one of the endpoints for the interpolation interval, compositing it with the
+/// underlying value if needed.
+/// An None returned value means, "Just use endpoint_value as-is."
+/// It is the responsibility of the caller to ensure that |underlying_value| is provided
+/// when it will be used.
+fn composite_endpoint(
+    endpoint_value: Option<&AnimationValue>,
+    composite: CompositeOperation,
+    underlying_value: Option<&AnimationValue>,
+) -> Option<AnimationValue> {
+    match endpoint_value {
+        Some(endpoint_value) => match composite {
+            CompositeOperation::Add => underlying_value
+                .expect("We should have an underlying_value")
+                .animate(endpoint_value, Procedure::Add)
+                .ok(),
+            CompositeOperation::Accumulate => underlying_value
+                .expect("We should have an underlying value")
+                .animate(endpoint_value, Procedure::Accumulate { count: 1 })
+                .ok(),
+            _ => None,
+        },
+        None => underlying_value.map(|v| v.clone()),
+    }
+}
+
+/// Accumulate one of the endpoints of the animation interval.
+/// A returned value of None means, "Just use endpoint_value as-is."
+fn accumulate_endpoint(
+    endpoint_value: Option<&AnimationValue>,
+    composited_value: Option<AnimationValue>,
+    last_value: &AnimationValue,
+    current_iteration: u64,
+) -> Option<AnimationValue> {
+    debug_assert!(
+        endpoint_value.is_some() || composited_value.is_some(),
+        "Should have a suitable value to use"
+    );
+
+    let count = current_iteration;
+    match composited_value {
+        Some(endpoint) => last_value
+            .animate(&endpoint, Procedure::Accumulate { count })
+            .ok()
+            .or(Some(endpoint)),
+        None => last_value
+            .animate(endpoint_value.unwrap(), Procedure::Accumulate { count })
+            .ok(),
+    }
+}
+
+/// Compose the animation segment. We composite it with the underlying_value and last_value if
+/// needed.
+/// The caller is responsible for providing an underlying value and last value
+/// in all situations where there are needed.
+fn compose_animation_segment(
+    segment: &structs::AnimationPropertySegment,
+    underlying_value: Option<&AnimationValue>,
+    last_value: Option<&AnimationValue>,
+    iteration_composite: IterationCompositeOperation,
+    current_iteration: u64,
+    total_progress: f64,
+    segment_progress: f64,
+) -> AnimationValue {
+    // Extract keyframe values.
+    let keyframe_from_value = unsafe { segment.mFromValue.mServo.mRawPtr.as_ref() };
+    let keyframe_to_value = unsafe { segment.mToValue.mServo.mRawPtr.as_ref() };
+    let mut composited_from_value = composite_endpoint(
+        keyframe_from_value,
+        segment.mFromComposite,
+        underlying_value,
+    );
+    let mut composited_to_value =
+        composite_endpoint(keyframe_to_value, segment.mToComposite, underlying_value);
+
+    debug_assert!(
+        keyframe_from_value.is_some() || composited_from_value.is_some(),
+        "Should have a suitable from value to use"
+    );
+    debug_assert!(
+        keyframe_to_value.is_some() || composited_to_value.is_some(),
+        "Should have a suitable to value to use"
+    );
+
+    // Apply iteration composite behavior.
+    if iteration_composite == IterationCompositeOperation::Accumulate && current_iteration > 0 {
+        let last_value = last_value
+            .unwrap_or_else(|| underlying_value.expect("Should have a valid underlying value"));
+
+        composited_from_value = accumulate_endpoint(
+            keyframe_from_value,
+            composited_from_value,
+            last_value,
+            current_iteration,
+        );
+        composited_to_value = accumulate_endpoint(
+            keyframe_to_value,
+            composited_to_value,
+            last_value,
+            current_iteration,
+        );
+    }
+
+    // Use the composited value if there is one, otherwise, use the original keyframe value.
+    let from = composited_from_value
+        .as_ref()
+        .unwrap_or_else(|| keyframe_from_value.unwrap());
+    let to = composited_to_value
+        .as_ref()
+        .unwrap_or_else(|| keyframe_to_value.unwrap());
+
+    if segment.mToKey == segment.mFromKey {
+        return if total_progress < 0. {
+            from.clone()
+        } else {
+            to.clone()
+        };
+    }
+
+    match from.animate(
+        to,
+        Procedure::Interpolate {
+            progress: segment_progress,
+        },
+    ) {
+        Ok(value) => value,
+        _ => {
+            if segment_progress < 0.5 {
+                from.clone()
+            } else {
+                to.clone()
+            }
+        },
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ComposeAnimationSegment(
+    segment: &structs::AnimationPropertySegment,
+    underlying_value: Option<&AnimationValue>,
+    last_value: Option<&AnimationValue>,
+    iteration_composite: IterationCompositeOperation,
+    progress: f64,
+    current_iteration: u64,
+) -> Strong<AnimationValue> {
+    let result = compose_animation_segment(
+        segment,
+        underlying_value,
+        last_value,
+        iteration_composite,
+        current_iteration,
+        progress,
+        progress,
+    );
+    Arc::new(result).into()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AnimationCompose(
+    value_map: &mut AnimationValueMap,
+    base_values: &structs::RawServoAnimationValueTable,
+    css_property: nsCSSPropertyID,
+    segment: &structs::AnimationPropertySegment,
+    last_segment: &structs::AnimationPropertySegment,
+    computed_timing: &structs::ComputedTiming,
+    iteration_composite: IterationCompositeOperation,
+) {
+    use style::gecko_bindings::bindings::Gecko_AnimationGetBaseStyle;
+    use style::gecko_bindings::bindings::Gecko_GetPositionInSegment;
+    use style::gecko_bindings::bindings::Gecko_GetProgressFromComputedTiming;
+
+    let property = match LonghandId::from_nscsspropertyid(css_property) {
+        Ok(longhand) if longhand.is_animatable() => longhand,
+        _ => return,
+    };
+
+    // We will need an underlying value if either of the endpoints is null...
+    let need_underlying_value = segment.mFromValue.mServo.mRawPtr.is_null() ||
+                                segment.mToValue.mServo.mRawPtr.is_null() ||
+                                // ... or if they have a non-replace composite mode ...
+                                segment.mFromComposite != CompositeOperation::Replace ||
+                                segment.mToComposite != CompositeOperation::Replace ||
+                                // ... or if we accumulate onto the last value and it is null.
+                                (iteration_composite == IterationCompositeOperation::Accumulate &&
+                                 computed_timing.mCurrentIteration > 0 &&
+                                 last_segment.mToValue.mServo.mRawPtr.is_null());
+
+    // If either of the segment endpoints are null, get the underlying value to
+    // use from the current value in the values map (set by a lower-priority
+    // effect), or, if there is no current value, look up the cached base value
+    // for this property.
+    let underlying_value = if need_underlying_value {
+        let previous_composed_value = value_map.get(&property).map(|v| &*v);
+        previous_composed_value
+            .or_else(|| unsafe { Gecko_AnimationGetBaseStyle(base_values, css_property).as_ref() })
+    } else {
+        None
+    };
+
+    if need_underlying_value && underlying_value.is_none() {
+        warn!("Underlying value should be valid when we expect to use it");
+        return;
+    }
+
+    let last_value = unsafe { last_segment.mToValue.mServo.mRawPtr.as_ref() };
+    let progress = unsafe { Gecko_GetProgressFromComputedTiming(computed_timing) };
+    let position = if segment.mToKey == segment.mFromKey {
+        // Note: compose_animation_segment doesn't use this value
+        // if segment.mFromKey == segment.mToKey, so assigning |progress| directly is fine.
+        progress
+    } else {
+        unsafe { Gecko_GetPositionInSegment(segment, progress, computed_timing.mBeforeFlag) }
+    };
+
+    let result = compose_animation_segment(
+        segment,
+        underlying_value,
+        last_value,
+        iteration_composite,
+        computed_timing.mCurrentIteration,
+        progress,
+        position,
+    );
+    value_map.insert(property, result);
+}
+
+macro_rules! get_property_id_from_nscsspropertyid {
+    ($property_id: ident, $ret: expr) => {{
+        match PropertyId::from_nscsspropertyid($property_id) {
+            Ok(property_id) => property_id,
+            Err(()) => {
+                return $ret;
+            },
+        }
+    }};
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AnimationValue_Serialize(
+    value: &AnimationValue,
+    property: nsCSSPropertyID,
+    raw_data: &PerDocumentStyleData,
+    buffer: &mut nsACString,
+) {
+    let uncomputed_value = value.uncompute();
+    let data = raw_data.borrow();
+    let rv = PropertyDeclarationBlock::with_one(uncomputed_value, Importance::Normal)
+        .single_value_to_css(
+            &get_property_id_from_nscsspropertyid!(property, ()),
+            buffer,
+            None,
+            None, /* No extra custom properties */
+            &data.stylist.device(),
+        );
+    debug_assert!(rv.is_ok());
+}
+
+/// Debug: MOZ_DBG for AnimationValue.
+#[no_mangle]
+pub extern "C" fn Servo_AnimationValue_Dump(value: &AnimationValue, result: &mut nsACString) {
+    write!(result, "{:?}", value).unwrap();
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AnimationValue_GetColor(
+    value: &AnimationValue,
+    foreground_color: structs::nscolor,
+) -> structs::nscolor {
+    use style::gecko::values::{
+        convert_absolute_color_to_nscolor, convert_nscolor_to_absolute_color,
+    };
+    use style::values::computed::color::Color as ComputedColor;
+    match *value {
+        AnimationValue::BackgroundColor(ref color) => {
+            let computed: ComputedColor = color.clone();
+            let foreground_color = convert_nscolor_to_absolute_color(foreground_color);
+            convert_absolute_color_to_nscolor(&computed.resolve_to_absolute(&foreground_color))
+        },
+        _ => panic!("Other color properties are not supported yet"),
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AnimationValue_IsCurrentColor(value: &AnimationValue) -> bool {
+    match *value {
+        AnimationValue::BackgroundColor(ref color) => color.is_currentcolor(),
+        _ => {
+            debug_assert!(false, "Other color properties are not supported yet");
+            false
+        },
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AnimationValue_GetOpacity(value: &AnimationValue) -> f32 {
+    if let AnimationValue::Opacity(opacity) = *value {
+        opacity
+    } else {
+        panic!("The AnimationValue should be Opacity");
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AnimationValue_Opacity(opacity: f32) -> Strong<AnimationValue> {
+    Arc::new(AnimationValue::Opacity(opacity)).into()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AnimationValue_Color(
+    color_property: nsCSSPropertyID,
+    color: structs::nscolor,
+) -> Strong<AnimationValue> {
+    use style::gecko::values::convert_nscolor_to_absolute_color;
+    use style::values::animated::color::Color;
+
+    let property = LonghandId::from_nscsspropertyid(color_property)
+        .expect("We don't have shorthand property animation value");
+
+    let animated = convert_nscolor_to_absolute_color(color);
+
+    match property {
+        LonghandId::BackgroundColor => {
+            Arc::new(AnimationValue::BackgroundColor(Color::Absolute(animated))).into()
+        },
+        _ => panic!("Should be background-color property"),
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AnimationValue_GetScale(
+    value: &AnimationValue,
+) -> *const computed::Scale {
+    match *value {
+        AnimationValue::Scale(ref value) => value,
+        _ => unreachable!("Expected scale"),
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AnimationValue_GetTranslate(
+    value: &AnimationValue,
+) -> *const computed::Translate {
+    match *value {
+        AnimationValue::Translate(ref value) => value,
+        _ => unreachable!("Expected translate"),
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AnimationValue_GetRotate(
+    value: &AnimationValue,
+) -> *const computed::Rotate {
+    match *value {
+        AnimationValue::Rotate(ref value) => value,
+        _ => unreachable!("Expected rotate"),
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AnimationValue_GetTransform(
+    value: &AnimationValue,
+) -> *const computed::Transform {
+    match *value {
+        AnimationValue::Transform(ref value) => value,
+        _ => unreachable!("Unsupported transform animation value"),
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AnimationValue_GetOffsetPath(
+    value: &AnimationValue,
+) -> *const computed::motion::OffsetPath {
+    match *value {
+        AnimationValue::OffsetPath(ref value) => value,
+        _ => unreachable!("Expected offset-path"),
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AnimationValue_GetOffsetDistance(
+    value: &AnimationValue,
+) -> *const computed::LengthPercentage {
+    match *value {
+        AnimationValue::OffsetDistance(ref value) => value,
+        _ => unreachable!("Expected offset-distance"),
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AnimationValue_GetOffsetRotate(
+    value: &AnimationValue,
+) -> *const computed::motion::OffsetRotate {
+    match *value {
+        AnimationValue::OffsetRotate(ref value) => value,
+        _ => unreachable!("Expected offset-rotate"),
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AnimationValue_GetOffsetAnchor(
+    value: &AnimationValue,
+) -> *const computed::position::PositionOrAuto {
+    match *value {
+        AnimationValue::OffsetAnchor(ref value) => value,
+        _ => unreachable!("Expected offset-anchor"),
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AnimationValue_Rotate(
+    r: &computed::Rotate,
+) -> Strong<AnimationValue> {
+    Arc::new(AnimationValue::Rotate(r.clone())).into()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AnimationValue_Translate(
+    t: &computed::Translate,
+) -> Strong<AnimationValue> {
+    Arc::new(AnimationValue::Translate(t.clone())).into()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AnimationValue_Scale(s: &computed::Scale) -> Strong<AnimationValue> {
+    Arc::new(AnimationValue::Scale(s.clone())).into()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AnimationValue_Transform(
+    transform: &computed::Transform,
+) -> Strong<AnimationValue> {
+    Arc::new(AnimationValue::Transform(transform.clone())).into()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AnimationValue_OffsetPath(
+    p: &computed::motion::OffsetPath,
+) -> Strong<AnimationValue> {
+    Arc::new(AnimationValue::OffsetPath(p.clone())).into()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AnimationValue_OffsetDistance(
+    d: &computed::LengthPercentage,
+) -> Strong<AnimationValue> {
+    Arc::new(AnimationValue::OffsetDistance(d.clone())).into()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AnimationValue_OffsetRotate(
+    r: &computed::motion::OffsetRotate,
+) -> Strong<AnimationValue> {
+    Arc::new(AnimationValue::OffsetRotate(*r)).into()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AnimationValue_OffsetAnchor(
+    p: &computed::position::PositionOrAuto,
+) -> Strong<AnimationValue> {
+    Arc::new(AnimationValue::OffsetAnchor(p.clone())).into()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AnimationValue_DeepEqual(
+    this: &AnimationValue,
+    other: &AnimationValue,
+) -> bool {
+    this == other
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AnimationValue_Uncompute(
+    value: &AnimationValue,
+) -> Strong<LockedDeclarationBlock> {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    Arc::new(
+        global_style_data
+            .shared_lock
+            .wrap(PropertyDeclarationBlock::with_one(
+                value.uncompute(),
+                Importance::Normal,
+            )),
+    )
+    .into()
+}
+
+#[inline]
+fn create_byte_buf_from_vec(mut v: Vec<u8>) -> ByteBuf {
+    let w = ByteBuf {
+        mData: v.as_mut_ptr(),
+        mLen: v.len(),
+        mCapacity: v.capacity(),
+    };
+    std::mem::forget(v);
+    w
+}
+
+#[inline]
+fn view_byte_buf(b: &ByteBuf) -> &[u8] {
+    if b.mData.is_null() {
+        debug_assert_eq!(b.mCapacity, 0);
+        return &[];
+    }
+    unsafe { std::slice::from_raw_parts(b.mData, b.mLen) }
+}
+
+macro_rules! impl_basic_serde_funcs {
+    ($ser_name:ident, $de_name:ident, $computed_type:ty) => {
+        #[no_mangle]
+        pub extern "C" fn $ser_name(v: &$computed_type, output: &mut ByteBuf) -> bool {
+            let buf = match serialize(v) {
+                Ok(buf) => buf,
+                Err(..) => return false,
+            };
+
+            *output = create_byte_buf_from_vec(buf);
+            true
+        }
+
+        #[no_mangle]
+        pub unsafe extern "C" fn $de_name(input: &ByteBuf, v: *mut $computed_type) -> bool {
+            let buf = match deserialize(view_byte_buf(input)) {
+                Ok(buf) => buf,
+                Err(..) => return false,
+            };
+
+            std::ptr::write(v, buf);
+            true
+        }
+    };
+}
+
+impl_basic_serde_funcs!(
+    Servo_LengthPercentage_Serialize,
+    Servo_LengthPercentage_Deserialize,
+    computed::LengthPercentage
+);
+
+impl_basic_serde_funcs!(
+    Servo_StyleRotate_Serialize,
+    Servo_StyleRotate_Deserialize,
+    computed::transform::Rotate
+);
+
+impl_basic_serde_funcs!(
+    Servo_StyleScale_Serialize,
+    Servo_StyleScale_Deserialize,
+    computed::transform::Scale
+);
+
+impl_basic_serde_funcs!(
+    Servo_StyleTranslate_Serialize,
+    Servo_StyleTranslate_Deserialize,
+    computed::transform::Translate
+);
+
+impl_basic_serde_funcs!(
+    Servo_StyleTransform_Serialize,
+    Servo_StyleTransform_Deserialize,
+    computed::transform::Transform
+);
+
+impl_basic_serde_funcs!(
+    Servo_StyleOffsetPath_Serialize,
+    Servo_StyleOffsetPath_Deserialize,
+    computed::motion::OffsetPath
+);
+
+impl_basic_serde_funcs!(
+    Servo_StyleOffsetRotate_Serialize,
+    Servo_StyleOffsetRotate_Deserialize,
+    computed::motion::OffsetRotate
+);
+
+impl_basic_serde_funcs!(
+    Servo_StylePositionOrAuto_Serialize,
+    Servo_StylePositionOrAuto_Deserialize,
+    computed::position::PositionOrAuto
+);
+
+impl_basic_serde_funcs!(
+    Servo_StyleComputedTimingFunction_Serialize,
+    Servo_StyleComputedTimingFunction_Deserialize,
+    ComputedTimingFunction
+);
+
+#[no_mangle]
+pub extern "C" fn Servo_SVGPathData_Normalize(
+    input: &specified::SVGPathData,
+    output: &mut specified::SVGPathData,
+) {
+    *output = input.normalize();
+}
+
+// Return the ComputedValues by a base ComputedValues and the rules.
+fn resolve_rules_for_element_with_context<'a>(
+    element: GeckoElement<'a>,
+    mut context: StyleContext<GeckoElement<'a>>,
+    rules: StrongRuleNode,
+    original_computed_values: &ComputedValues,
+) -> Arc<ComputedValues> {
+    use style::style_resolver::{PseudoElementResolution, StyleResolverForElement};
+
+    // This currently ignores visited styles, which seems acceptable, as
+    // existing browsers don't appear to animate visited styles.
+    let inputs = CascadeInputs {
+        rules: Some(rules),
+        visited_rules: None,
+        flags: original_computed_values.flags.for_cascade_inputs(),
+    };
+
+    // Actually `PseudoElementResolution` doesn't matter.
+    let mut resolver = StyleResolverForElement::new(
+        element,
+        &mut context,
+        RuleInclusion::All,
+        PseudoElementResolution::IfApplicable,
+    );
+    resolver
+        .cascade_style_and_visited_with_default_parents(inputs)
+        .0
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AnimationValueMap_Create() -> *mut AnimationValueMap {
+    Box::into_raw(Box::default())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AnimationValueMap_Drop(value_map: *mut AnimationValueMap) {
+    let _ = Box::from_raw(value_map);
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AnimationValueMap_GetValue(
+    value_map: &AnimationValueMap,
+    property_id: nsCSSPropertyID,
+) -> Strong<AnimationValue> {
+    let property = match LonghandId::from_nscsspropertyid(property_id) {
+        Ok(longhand) => longhand,
+        Err(()) => return Strong::null(),
+    };
+    value_map
+        .get(&property)
+        .map_or(Strong::null(), |value| Arc::new(value.clone()).into())
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_GetBaseComputedValuesForElement(
+    raw_style_set: &PerDocumentStyleData,
+    element: &RawGeckoElement,
+    computed_values: &ComputedValues,
+    snapshots: *const ServoElementSnapshotTable,
+) -> Strong<ComputedValues> {
+    debug_assert!(!snapshots.is_null());
+    let computed_values = unsafe { ArcBorrow::from_ref(computed_values) };
+
+    let rules = match computed_values.rules {
+        None => return computed_values.clone_arc().into(),
+        Some(ref rules) => rules,
+    };
+
+    let doc_data = raw_style_set.borrow();
+    let without_animations_rules = doc_data.stylist.rule_tree().remove_animation_rules(rules);
+    if without_animations_rules == *rules {
+        return computed_values.clone_arc().into();
+    }
+
+    let element = GeckoElement(element);
+
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    let shared = create_shared_context(
+        &global_style_data,
+        &guard,
+        &doc_data.stylist,
+        TraversalFlags::empty(),
+        unsafe { &*snapshots },
+    );
+    let mut tlc = ThreadLocalStyleContext::new();
+    let context = StyleContext {
+        shared: &shared,
+        thread_local: &mut tlc,
+    };
+
+    resolve_rules_for_element_with_context(
+        element,
+        context,
+        without_animations_rules,
+        &computed_values,
+    )
+    .into()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_GetComputedValuesByAddingAnimation(
+    raw_style_set: &PerDocumentStyleData,
+    element: &RawGeckoElement,
+    computed_values: &ComputedValues,
+    snapshots: *const ServoElementSnapshotTable,
+    animation_value: &AnimationValue,
+) -> Strong<ComputedValues> {
+    debug_assert!(!snapshots.is_null());
+    let rules = match computed_values.rules {
+        None => return Strong::null(),
+        Some(ref rules) => rules,
+    };
+
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    let uncomputed_value = animation_value.uncompute();
+    let doc_data = raw_style_set.borrow();
+
+    let with_animations_rules = {
+        let guards = StylesheetGuards::same(&guard);
+        let declarations = Arc::new(global_style_data.shared_lock.wrap(
+            PropertyDeclarationBlock::with_one(uncomputed_value, Importance::Normal),
+        ));
+        doc_data
+            .stylist
+            .rule_tree()
+            .add_animation_rules_at_transition_level(rules, declarations, &guards)
+    };
+
+    let element = GeckoElement(element);
+    if element.borrow_data().is_none() {
+        return Strong::null();
+    }
+
+    let shared = create_shared_context(
+        &global_style_data,
+        &guard,
+        &doc_data.stylist,
+        TraversalFlags::empty(),
+        unsafe { &*snapshots },
+    );
+    let mut tlc: ThreadLocalStyleContext<GeckoElement> = ThreadLocalStyleContext::new();
+    let context = StyleContext {
+        shared: &shared,
+        thread_local: &mut tlc,
+    };
+
+    resolve_rules_for_element_with_context(
+        element,
+        context,
+        with_animations_rules,
+        &computed_values,
+    )
+    .into()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ComputedValues_ExtractAnimationValue(
+    computed_values: &ComputedValues,
+    property_id: nsCSSPropertyID,
+) -> Strong<AnimationValue> {
+    let property = match LonghandId::from_nscsspropertyid(property_id) {
+        Ok(longhand) => longhand,
+        Err(()) => return Strong::null(),
+    };
+    match AnimationValue::from_computed_values(property, &computed_values) {
+        Some(v) => Arc::new(v).into(),
+        None => Strong::null(),
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ResolveLogicalProperty(
+    property_id: nsCSSPropertyID,
+    style: &ComputedValues,
+) -> nsCSSPropertyID {
+    let longhand = LonghandId::from_nscsspropertyid(property_id)
+        .expect("We shouldn't need to care about shorthands");
+
+    longhand
+        .to_physical(style.writing_mode)
+        .to_nscsspropertyid()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_Property_LookupEnabledForAllContent(
+    prop: &nsACString,
+) -> nsCSSPropertyID {
+    match PropertyId::parse_enabled_for_all_content(prop.as_str_unchecked()) {
+        Ok(p) => p.to_nscsspropertyid_resolving_aliases(),
+        Err(..) => nsCSSPropertyID::eCSSProperty_UNKNOWN,
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_Property_GetName(
+    prop: nsCSSPropertyID,
+    out_length: *mut u32,
+) -> *const u8 {
+    let (ptr, len) = match NonCustomPropertyId::from_nscsspropertyid(prop) {
+        Ok(p) => {
+            let name = p.name();
+            (name.as_bytes().as_ptr(), name.len())
+        },
+        Err(..) => (ptr::null(), 0),
+    };
+
+    *out_length = len as u32;
+    ptr
+}
+
+macro_rules! parse_enabled_property_name {
+    ($prop_name:ident, $found:ident, $default:expr) => {{
+        let prop_name = $prop_name.as_str_unchecked();
+        match PropertyId::parse_enabled_for_all_content(prop_name) {
+            Ok(p) => {
+                *$found = true;
+                p
+            },
+            Err(..) => {
+                *$found = false;
+                return $default;
+            },
+        }
+    }};
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_Property_IsShorthand(
+    prop_name: &nsACString,
+    found: *mut bool,
+) -> bool {
+    let prop_id = parse_enabled_property_name!(prop_name, found, false);
+    prop_id.is_shorthand()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_Property_IsInherited(prop_name: &nsACString) -> bool {
+    let prop_name = prop_name.as_str_unchecked();
+    let prop_id = match PropertyId::parse_enabled_for_all_content(prop_name) {
+        Ok(id) => id,
+        Err(_) => return false,
+    };
+    let longhand_id = match prop_id {
+        PropertyId::Custom(_) => return true,
+        PropertyId::Longhand(id) | PropertyId::LonghandAlias(id, _) => id,
+        PropertyId::Shorthand(id) | PropertyId::ShorthandAlias(id, _) => {
+            id.longhands().next().unwrap()
+        },
+    };
+    longhand_id.inherited()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_Property_SupportsType(
+    prop_name: &nsACString,
+    ty: u8,
+    found: *mut bool,
+) -> bool {
+    let prop_id = parse_enabled_property_name!(prop_name, found, false);
+    prop_id.supports_type(ty)
+}
+
+// TODO(emilio): We could use ThinVec instead of nsTArray.
+#[no_mangle]
+pub unsafe extern "C" fn Servo_Property_GetCSSValuesForProperty(
+    prop_name: &nsACString,
+    found: *mut bool,
+    result: &mut nsTArray<nsString>,
+) {
+    let prop_id = parse_enabled_property_name!(prop_name, found, ());
+    // Use B-tree set for unique and sorted result.
+    let mut values = BTreeSet::<&'static str>::new();
+    prop_id.collect_property_completion_keywords(&mut |list| values.extend(list.iter()));
+
+    let mut extras = vec![];
+    if values.contains("transparent") {
+        // This is a special value devtools use to avoid inserting the
+        // long list of color keywords. We need to prepend it to values.
+        extras.push("COLOR");
+    }
+
+    let len = extras.len() + values.len();
+    bindings::Gecko_ResizeTArrayForStrings(result, len as u32);
+
+    for (src, dest) in extras.iter().chain(values.iter()).zip(result.iter_mut()) {
+        dest.write_str(src).unwrap();
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_Property_IsAnimatable(prop: nsCSSPropertyID) -> bool {
+    NonCustomPropertyId::from_nscsspropertyid(prop)
+        .ok()
+        .map_or(false, |p| p.is_animatable())
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_Property_IsTransitionable(prop: nsCSSPropertyID) -> bool {
+    NonCustomPropertyId::from_nscsspropertyid(prop)
+        .ok()
+        .map_or(false, |p| p.is_transitionable())
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_Property_IsDiscreteAnimatable(property: nsCSSPropertyID) -> bool {
+    match LonghandId::from_nscsspropertyid(property) {
+        Ok(longhand) => longhand.is_discrete_animatable(),
+        Err(()) => return false,
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_Element_ClearData(element: &RawGeckoElement) {
+    unsafe { GeckoElement(element).clear_data() };
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_Element_SizeOfExcludingThisAndCVs(
+    malloc_size_of: GeckoMallocSizeOf,
+    malloc_enclosing_size_of: GeckoMallocSizeOf,
+    seen_ptrs: *mut SeenPtrs,
+    element: &RawGeckoElement,
+) -> usize {
+    let element = GeckoElement(element);
+    let borrow = element.borrow_data();
+    if let Some(data) = borrow {
+        let have_seen_ptr = move |ptr| unsafe { Gecko_HaveSeenPtr(seen_ptrs, ptr) };
+        let mut ops = MallocSizeOfOps::new(
+            malloc_size_of.unwrap(),
+            Some(malloc_enclosing_size_of.unwrap()),
+            Some(Box::new(have_seen_ptr)),
+        );
+        (*data).size_of_excluding_cvs(&mut ops)
+    } else {
+        0
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_Element_GetMaybeOutOfDateStyle(
+    element: &RawGeckoElement,
+) -> *const ComputedValues {
+    let element = GeckoElement(element);
+    let data = match element.borrow_data() {
+        Some(d) => d,
+        None => return ptr::null(),
+    };
+    &**data.styles.primary() as *const _
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_Element_GetMaybeOutOfDatePseudoStyle(
+    element: &RawGeckoElement,
+    index: usize,
+) -> *const ComputedValues {
+    let element = GeckoElement(element);
+    let data = match element.borrow_data() {
+        Some(d) => d,
+        None => return ptr::null(),
+    };
+    match data.styles.pseudos.as_array()[index].as_ref() {
+        Some(style) => &**style as *const _,
+        None => ptr::null(),
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_Element_IsDisplayNone(element: &RawGeckoElement) -> bool {
+    let element = GeckoElement(element);
+    let data = element
+        .get_data()
+        .expect("Invoking Servo_Element_IsDisplayNone on unstyled element");
+
+    // This function is hot, so we bypass the AtomicRefCell.
+    //
+    // It would be nice to also assert that we're not in the servo traversal,
+    // but this function is called at various intermediate checkpoints when
+    // managing the traversal on the Gecko side.
+    debug_assert!(is_main_thread());
+    unsafe { &*data.as_ptr() }.styles.is_display_none()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_Element_IsDisplayContents(element: &RawGeckoElement) -> bool {
+    let element = GeckoElement(element);
+    let data = element
+        .get_data()
+        .expect("Invoking Servo_Element_IsDisplayContents on unstyled element");
+
+    debug_assert!(is_main_thread());
+    unsafe { &*data.as_ptr() }
+        .styles
+        .primary()
+        .get_box()
+        .clone_display()
+        .is_contents()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_Element_IsPrimaryStyleReusedViaRuleNode(element: &RawGeckoElement) -> bool {
+    let element = GeckoElement(element);
+    let data = element
+        .borrow_data()
+        .expect("Invoking Servo_Element_IsPrimaryStyleReusedViaRuleNode on unstyled element");
+    data.flags
+        .contains(data::ElementDataFlags::PRIMARY_STYLE_REUSED_VIA_RULE_NODE)
+}
+
+fn mode_to_origin(mode: SheetParsingMode) -> Origin {
+    match mode {
+        SheetParsingMode::eAuthorSheetFeatures => Origin::Author,
+        SheetParsingMode::eUserSheetFeatures => Origin::User,
+        SheetParsingMode::eAgentSheetFeatures => Origin::UserAgent,
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSheet_Empty(mode: SheetParsingMode) -> Strong<StylesheetContents> {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let origin = mode_to_origin(mode);
+    let shared_lock = &global_style_data.shared_lock;
+    StylesheetContents::from_str(
+        "",
+        unsafe { dummy_url_data() }.clone(),
+        origin,
+        shared_lock,
+        /* loader = */ None,
+        None,
+        QuirksMode::NoQuirks,
+        0,
+        /* use_counters = */ None,
+        AllowImportRules::Yes,
+        /* sanitization_data = */ None,
+    )
+    .into()
+}
+
+/// Note: The load_data corresponds to this sheet, and is passed as the parent
+/// load data for child sheet loads. It may be null for certain cases where we
+/// know we won't have child loads.
+#[no_mangle]
+pub unsafe extern "C" fn Servo_StyleSheet_FromUTF8Bytes(
+    loader: *mut Loader,
+    stylesheet: *mut DomStyleSheet,
+    load_data: *mut SheetLoadData,
+    bytes: &nsACString,
+    mode: SheetParsingMode,
+    extra_data: *mut URLExtraData,
+    line_number_offset: u32,
+    quirks_mode: nsCompatibility,
+    reusable_sheets: *mut LoaderReusableStyleSheets,
+    use_counters: Option<&UseCounters>,
+    allow_import_rules: AllowImportRules,
+    sanitization_kind: SanitizationKind,
+    sanitized_output: Option<&mut nsAString>,
+) -> Strong<StylesheetContents> {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let input = bytes.as_str_unchecked();
+
+    let reporter = ErrorReporter::new(stylesheet, loader, extra_data);
+    let url_data = UrlExtraData::from_ptr_ref(&extra_data);
+    let loader = if loader.is_null() {
+        None
+    } else {
+        debug_assert!(
+            sanitized_output.is_none(),
+            "Shouldn't trigger @import loads for sanitization",
+        );
+        Some(StylesheetLoader::new(
+            loader,
+            stylesheet,
+            load_data,
+            reusable_sheets,
+        ))
+    };
+
+    // FIXME(emilio): loader.as_ref() doesn't typecheck for some reason?
+    let loader: Option<&dyn StyleStylesheetLoader> = match loader {
+        None => None,
+        Some(ref s) => Some(s),
+    };
+
+    let mut sanitization_data = SanitizationData::new(sanitization_kind);
+
+    let contents = StylesheetContents::from_str(
+        input,
+        url_data.clone(),
+        mode_to_origin(mode),
+        &global_style_data.shared_lock,
+        loader,
+        reporter.as_ref().map(|r| r as &dyn ParseErrorReporter),
+        quirks_mode.into(),
+        line_number_offset,
+        use_counters,
+        allow_import_rules,
+        sanitization_data.as_mut(),
+    );
+
+    if let Some(data) = sanitization_data {
+        sanitized_output
+            .unwrap()
+            .assign_utf8(data.take().as_bytes());
+    }
+
+    contents.into()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_StyleSheet_FromUTF8BytesAsync(
+    load_data: *mut SheetLoadDataHolder,
+    extra_data: *mut URLExtraData,
+    bytes: &nsACString,
+    mode: SheetParsingMode,
+    line_number_offset: u32,
+    quirks_mode: nsCompatibility,
+    should_record_use_counters: bool,
+    allow_import_rules: AllowImportRules,
+) {
+    let load_data = RefPtr::new(load_data);
+    let extra_data = UrlExtraData::new(extra_data);
+
+    let mut sheet_bytes = nsCString::new();
+    sheet_bytes.assign(bytes);
+
+    let async_parser = AsyncStylesheetParser::new(
+        load_data,
+        extra_data,
+        sheet_bytes,
+        mode_to_origin(mode),
+        quirks_mode.into(),
+        line_number_offset,
+        should_record_use_counters,
+        allow_import_rules,
+    );
+
+    if let Some(thread_pool) = STYLE_THREAD_POOL.pool().as_ref() {
+        thread_pool.spawn(|| {
+            gecko_profiler_label!(Layout, CSSParsing);
+            async_parser.parse();
+        });
+    } else {
+        async_parser.parse();
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_ShutdownThreadPool() {
+    debug_assert!(is_main_thread() && !is_in_servo_traversal());
+    StyleThreadPool::shutdown();
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_StyleSheet_FromSharedData(
+    extra_data: *mut URLExtraData,
+    shared_rules: &LockedCssRules,
+) -> Strong<StylesheetContents> {
+    StylesheetContents::from_shared_data(
+        Arc::from_raw_addrefed(shared_rules),
+        Origin::UserAgent,
+        UrlExtraData::new(extra_data),
+        QuirksMode::NoQuirks,
+    )
+    .into()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_AppendStyleSheet(
+    raw_data: &PerDocumentStyleData,
+    sheet: *const DomStyleSheet,
+) {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let mut data = raw_data.borrow_mut();
+    let data = &mut *data;
+    let guard = global_style_data.shared_lock.read();
+    let sheet = unsafe { GeckoStyleSheet::new(sheet) };
+    data.stylist.append_stylesheet(sheet, &guard);
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AuthorStyles_Create() -> *mut AuthorStyles {
+    Box::into_raw(Box::new(AuthorStyles::new()))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AuthorStyles_Drop(styles: *mut AuthorStyles) {
+    let _ = Box::from_raw(styles);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AuthorStyles_AppendStyleSheet(
+    styles: &mut AuthorStyles,
+    sheet: *const DomStyleSheet,
+) {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    let sheet = GeckoStyleSheet::new(sheet);
+    styles.stylesheets.append_stylesheet(None, sheet, &guard);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AuthorStyles_InsertStyleSheetBefore(
+    styles: &mut AuthorStyles,
+    sheet: *const DomStyleSheet,
+    before_sheet: *const DomStyleSheet,
+) {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    styles.stylesheets.insert_stylesheet_before(
+        None,
+        GeckoStyleSheet::new(sheet),
+        GeckoStyleSheet::new(before_sheet),
+        &guard,
+    );
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AuthorStyles_RemoveStyleSheet(
+    styles: &mut AuthorStyles,
+    sheet: *const DomStyleSheet,
+) {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    styles
+        .stylesheets
+        .remove_stylesheet(None, GeckoStyleSheet::new(sheet), &guard);
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AuthorStyles_ForceDirty(styles: &mut AuthorStyles) {
+    styles.stylesheets.force_dirty();
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AuthorStyles_IsDirty(styles: &AuthorStyles) -> bool {
+    styles.stylesheets.dirty()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AuthorStyles_Flush(
+    styles: &mut AuthorStyles,
+    document_set: &PerDocumentStyleData,
+) {
+    // Try to avoid the atomic borrow below if possible.
+    if !styles.stylesheets.dirty() {
+        return;
+    }
+
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+
+    let mut document_data = document_set.borrow_mut();
+
+    // TODO(emilio): This is going to need an element or something to do proper
+    // invalidation in Shadow roots.
+    styles.flush::<GeckoElement>(&mut document_data.stylist, &guard);
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_RemoveUniqueEntriesFromAuthorStylesCache(
+    document_set: &PerDocumentStyleData,
+) {
+    let mut document_data = document_set.borrow_mut();
+    document_data
+        .stylist
+        .remove_unique_author_data_cache_entries();
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_DeclarationBlock_SizeOfIncludingThis(
+    malloc_size_of: GeckoMallocSizeOf,
+    malloc_enclosing_size_of: GeckoMallocSizeOf,
+    declarations: &LockedDeclarationBlock,
+) -> usize {
+    use malloc_size_of::MallocSizeOf;
+    use malloc_size_of::MallocUnconditionalShallowSizeOf;
+
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+
+    let mut ops = MallocSizeOfOps::new(
+        malloc_size_of.unwrap(),
+        Some(malloc_enclosing_size_of.unwrap()),
+        None,
+    );
+
+    ArcBorrow::from_ref(declarations).with_arc(|declarations| {
+        let mut n = 0;
+        n += declarations.unconditional_shallow_size_of(&mut ops);
+        n += declarations.read_with(&guard).size_of(&mut ops);
+        n
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_AuthorStyles_SizeOfIncludingThis(
+    malloc_size_of: GeckoMallocSizeOf,
+    malloc_enclosing_size_of: GeckoMallocSizeOf,
+    styles: &AuthorStyles,
+) -> usize {
+    // We cannot `use` MallocSizeOf at the top level, otherwise the compiler
+    // would complain in `Servo_StyleSheet_SizeOfIncludingThis` for `size_of`
+    // there.
+    use malloc_size_of::MallocSizeOf;
+    let malloc_size_of = malloc_size_of.unwrap();
+    let malloc_size_of_this = malloc_size_of(styles as *const AuthorStyles as *const c_void);
+
+    let mut ops = MallocSizeOfOps::new(
+        malloc_size_of,
+        Some(malloc_enclosing_size_of.unwrap()),
+        None,
+    );
+    malloc_size_of_this + styles.size_of(&mut ops)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_StyleSet_MediumFeaturesChanged(
+    document_set: &PerDocumentStyleData,
+    non_document_styles: &mut nsTArray<&mut AuthorStyles>,
+    may_affect_default_style: bool,
+) -> structs::MediumFeaturesChangedResult {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+
+    // NOTE(emilio): We don't actually need to flush the stylist here and ensure
+    // it's up to date.
+    //
+    // In case it isn't we would trigger a rebuild + restyle as needed too.
+    //
+    // We need to ensure the default computed values are up to date though,
+    // because those can influence the result of media query evaluation.
+    let mut document_data = document_set.borrow_mut();
+
+    if may_affect_default_style {
+        document_data.stylist.device_mut().reset_computed_values();
+    }
+    let guards = StylesheetGuards::same(&guard);
+
+    let origins_in_which_rules_changed = document_data
+        .stylist
+        .media_features_change_changed_style(&guards, document_data.stylist.device());
+
+    let affects_document_rules = !origins_in_which_rules_changed.is_empty();
+    if affects_document_rules {
+        document_data
+            .stylist
+            .force_stylesheet_origins_dirty(origins_in_which_rules_changed);
+    }
+
+    let mut affects_non_document_rules = false;
+    for author_styles in &mut **non_document_styles {
+        let affected_style = author_styles.stylesheets.iter().any(|sheet| {
+            !author_styles.data.media_feature_affected_matches(
+                sheet,
+                &guards.author,
+                document_data.stylist.device(),
+                document_data.stylist.quirks_mode(),
+            )
+        });
+        if affected_style {
+            affects_non_document_rules = true;
+            author_styles.stylesheets.force_dirty();
+        }
+    }
+
+    structs::MediumFeaturesChangedResult {
+        mAffectsDocumentRules: affects_document_rules,
+        mAffectsNonDocumentRules: affects_non_document_rules,
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_InsertStyleSheetBefore(
+    raw_data: &PerDocumentStyleData,
+    sheet: *const DomStyleSheet,
+    before_sheet: *const DomStyleSheet,
+) {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let mut data = raw_data.borrow_mut();
+    let data = &mut *data;
+    let guard = global_style_data.shared_lock.read();
+    let sheet = unsafe { GeckoStyleSheet::new(sheet) };
+    data.stylist.insert_stylesheet_before(
+        sheet,
+        unsafe { GeckoStyleSheet::new(before_sheet) },
+        &guard,
+    );
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_RemoveStyleSheet(
+    raw_data: &PerDocumentStyleData,
+    sheet: *const DomStyleSheet,
+) {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let mut data = raw_data.borrow_mut();
+    let data = &mut *data;
+    let guard = global_style_data.shared_lock.read();
+    let sheet = unsafe { GeckoStyleSheet::new(sheet) };
+    data.stylist.remove_stylesheet(sheet, &guard);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_StyleSet_GetSheetAt(
+    raw_data: &PerDocumentStyleData,
+    origin: Origin,
+    index: usize,
+) -> *const DomStyleSheet {
+    let data = raw_data.borrow();
+    data.stylist
+        .sheet_at(origin, index)
+        .map_or(ptr::null(), |s| s.raw())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_StyleSet_GetSheetCount(
+    raw_data: &PerDocumentStyleData,
+    origin: Origin,
+) -> usize {
+    let data = raw_data.borrow();
+    data.stylist.sheet_count(origin)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_StyleSet_FlushStyleSheets(
+    raw_data: &PerDocumentStyleData,
+    doc_element: Option<&RawGeckoElement>,
+    snapshots: *const ServoElementSnapshotTable,
+) {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    let mut data = raw_data.borrow_mut();
+    let doc_element = doc_element.map(GeckoElement);
+
+    let have_invalidations = data.flush_stylesheets(&guard, doc_element, snapshots.as_ref());
+
+    if have_invalidations && doc_element.is_some() {
+        // The invalidation machinery propagates the bits up, but we still need
+        // to tell the Gecko restyle root machinery about it.
+        bindings::Gecko_NoteDirtySubtreeForInvalidation(doc_element.unwrap().0);
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_NoteStyleSheetsChanged(
+    raw_data: &PerDocumentStyleData,
+    changed_origins: OriginFlags,
+) {
+    let mut data = raw_data.borrow_mut();
+    data.stylist
+        .force_stylesheet_origins_dirty(OriginSet::from(changed_origins));
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_SetAuthorStyleDisabled(
+    raw_data: &PerDocumentStyleData,
+    author_style_disabled: bool,
+) {
+    let mut data = raw_data.borrow_mut();
+    let enabled = if author_style_disabled {
+        AuthorStylesEnabled::No
+    } else {
+        AuthorStylesEnabled::Yes
+    };
+    data.stylist.set_author_styles_enabled(enabled);
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_UsesFontMetrics(raw_data: &PerDocumentStyleData) -> bool {
+    let doc_data = raw_data;
+    doc_data.borrow().stylist.device().used_font_metrics()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSheet_HasRules(raw_contents: &StylesheetContents) -> bool {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    !raw_contents.rules.read_with(&guard).0.is_empty()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSheet_GetRules(sheet: &StylesheetContents) -> Strong<LockedCssRules> {
+    sheet.rules.clone().into()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSheet_Clone(
+    contents: &StylesheetContents,
+    reference_sheet: *const DomStyleSheet,
+) -> Strong<StylesheetContents> {
+    use style::shared_lock::{DeepCloneParams, DeepCloneWithLock};
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    let params = DeepCloneParams { reference_sheet };
+
+    Arc::new(contents.deep_clone_with_lock(&global_style_data.shared_lock, &guard, &params)).into()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSheet_SizeOfIncludingThis(
+    malloc_size_of: GeckoMallocSizeOf,
+    malloc_enclosing_size_of: GeckoMallocSizeOf,
+    sheet: &StylesheetContents,
+) -> usize {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    let mut ops = MallocSizeOfOps::new(
+        malloc_size_of.unwrap(),
+        Some(malloc_enclosing_size_of.unwrap()),
+        None,
+    );
+    // TODO(emilio): We're not measuring the size of the Arc<StylesheetContents>
+    // allocation itself here.
+    sheet.size_of(&guard, &mut ops)
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSheet_GetOrigin(sheet: &StylesheetContents) -> Origin {
+    sheet.origin
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSheet_GetSourceMapURL(
+    contents: &StylesheetContents,
+    result: &mut nsAString,
+) {
+    let url_opt = contents.source_map_url.read();
+    if let Some(ref url) = *url_opt {
+        write!(result, "{}", url).unwrap();
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSheet_GetSourceURL(
+    contents: &StylesheetContents,
+    result: &mut nsAString,
+) {
+    let url_opt = contents.source_url.read();
+    if let Some(ref url) = *url_opt {
+        write!(result, "{}", url).unwrap();
+    }
+}
+
+fn with_maybe_worker_shared_lock<R>(func: impl FnOnce(&SharedRwLock) -> R) -> R {
+    if is_dom_worker_thread() {
+        DOM_WORKER_RWLOCK.with(func)
+    } else {
+        func(&GLOBAL_STYLE_DATA.shared_lock)
+    }
+}
+
+fn read_locked_arc<T, R, F>(raw: &Locked<T>, func: F) -> R
+where
+    F: FnOnce(&T) -> R,
+{
+    debug_assert!(!is_dom_worker_thread());
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    func(raw.read_with(&guard))
+}
+
+fn read_locked_arc_worker<T, R, F>(raw: &Locked<T>, func: F) -> R
+where
+    F: FnOnce(&T) -> R,
+{
+    with_maybe_worker_shared_lock(|lock| {
+        let guard = lock.read();
+        func(raw.read_with(&guard))
+    })
+}
+
+#[cfg(debug_assertions)]
+unsafe fn read_locked_arc_unchecked<T, R, F>(raw: &Locked<T>, func: F) -> R
+where
+    F: FnOnce(&T) -> R,
+{
+    debug_assert!(is_main_thread() && !is_in_servo_traversal());
+    read_locked_arc(raw, func)
+}
+
+#[cfg(not(debug_assertions))]
+unsafe fn read_locked_arc_unchecked<T, R, F>(raw: &Locked<T>, func: F) -> R
+where
+    F: FnOnce(&T) -> R,
+{
+    debug_assert!(!is_dom_worker_thread());
+    func(raw.read_unchecked())
+}
+
+fn write_locked_arc<T, R, F>(raw: &Locked<T>, func: F) -> R
+where
+    F: FnOnce(&mut T) -> R,
+{
+    debug_assert!(!is_dom_worker_thread());
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let mut guard = global_style_data.shared_lock.write();
+    func(raw.write_with(&mut guard))
+}
+
+fn write_locked_arc_worker<T, R, F>(raw: &Locked<T>, func: F) -> R
+where
+    F: FnOnce(&mut T) -> R,
+{
+    with_maybe_worker_shared_lock(|lock| {
+        let mut guard = lock.write();
+        func(raw.write_with(&mut guard))
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_CssRules_ListTypes(rules: &LockedCssRules, result: &mut nsTArray<usize>) {
+    read_locked_arc(rules, |rules: &CssRules| {
+        result.assign_from_iter_pod(rules.0.iter().map(|rule| rule.rule_type() as usize));
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_CssRules_InsertRule(
+    rules: &LockedCssRules,
+    contents: &StylesheetContents,
+    rule: &nsACString,
+    index: u32,
+    nested: bool,
+    loader: *mut Loader,
+    allow_import_rules: AllowImportRules,
+    gecko_stylesheet: *mut DomStyleSheet,
+    rule_type: &mut CssRuleType,
+) -> nsresult {
+    let loader = if loader.is_null() {
+        None
+    } else {
+        Some(StylesheetLoader::new(
+            loader,
+            gecko_stylesheet,
+            ptr::null_mut(),
+            ptr::null_mut(),
+        ))
+    };
+    let loader = loader
+        .as_ref()
+        .map(|loader| loader as &dyn StyleStylesheetLoader);
+    let rule = unsafe { rule.as_str_unchecked() };
+
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let result = rules.insert_rule(
+        &global_style_data.shared_lock,
+        rule,
+        contents,
+        index as usize,
+        nested,
+        loader,
+        allow_import_rules,
+    );
+
+    match result {
+        Ok(new_rule) => {
+            *rule_type = new_rule.rule_type();
+            nsresult::NS_OK
+        },
+        Err(err) => err.into(),
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_CssRules_DeleteRule(rules: &LockedCssRules, index: u32) -> nsresult {
+    write_locked_arc(rules, |rules: &mut CssRules| {
+        match rules.remove_rule(index as usize) {
+            Ok(_) => nsresult::NS_OK,
+            Err(err) => err.into(),
+        }
+    })
+}
+
+trait MaybeLocked<Target> {
+    fn maybe_locked_read<'a>(&'a self, guard: &'a SharedRwLockReadGuard) -> &'a Target;
+}
+
+impl<T> MaybeLocked<T> for T {
+    fn maybe_locked_read<'a>(&'a self, _: &'a SharedRwLockReadGuard) -> &'a T {
+        self
+    }
+}
+
+impl<T> MaybeLocked<T> for Locked<T> {
+    fn maybe_locked_read<'a>(&'a self, guard: &'a SharedRwLockReadGuard) -> &'a T {
+        self.read_with(guard)
+    }
+}
+
+macro_rules! impl_basic_rule_funcs_without_getter {
+    {
+        ($rule_type:ty, $maybe_locked_rule_type:ty),
+        debug: $debug:ident,
+        to_css: $to_css:ident,
+    } => {
+        #[cfg(debug_assertions)]
+        #[no_mangle]
+        pub extern "C" fn $debug(rule: &$maybe_locked_rule_type, result: &mut nsACString) {
+            let global_style_data = &*GLOBAL_STYLE_DATA;
+            let guard = global_style_data.shared_lock.read();
+            let rule: &$rule_type = rule.maybe_locked_read(&guard);
+            write!(result, "{:?}", *rule).unwrap();
+        }
+
+        #[cfg(not(debug_assertions))]
+        #[no_mangle]
+        pub extern "C" fn $debug(_: &$maybe_locked_rule_type, _: &mut nsACString) {
+            unreachable!()
+        }
+
+        #[no_mangle]
+        pub extern "C" fn $to_css(rule: &$maybe_locked_rule_type, result: &mut nsACString) {
+            let global_style_data = &*GLOBAL_STYLE_DATA;
+            let guard = global_style_data.shared_lock.read();
+            let rule: &$rule_type = rule.maybe_locked_read(&guard);
+            rule.to_css(&guard, result).unwrap();
+        }
+    }
+}
+
+macro_rules! impl_basic_rule_funcs {
+    { ($name:ident, $rule_type:ty, $maybe_locked_rule_type:ty),
+        getter: $getter:ident,
+        debug: $debug:ident,
+        to_css: $to_css:ident,
+        changed: $changed:ident,
+    } => {
+        #[no_mangle]
+        pub extern "C" fn $getter(
+            rules: &LockedCssRules,
+            index: u32,
+            line: &mut u32,
+            column: &mut u32,
+        ) -> Strong<$maybe_locked_rule_type> {
+            let global_style_data = &*GLOBAL_STYLE_DATA;
+            let guard = global_style_data.shared_lock.read();
+            let rules = rules.read_with(&guard);
+            let index = index as usize;
+
+            if index >= rules.0.len() {
+                return Strong::null();
+            }
+
+            match rules.0[index] {
+                CssRule::$name(ref arc) => {
+                    let rule: &$rule_type = (&**arc).maybe_locked_read(&guard);
+                    let location = rule.source_location;
+                    *line = location.line as u32;
+                    *column = location.column as u32;
+                    arc.clone().into()
+                },
+                _ => {
+                    Strong::null()
+                }
+            }
+        }
+
+        #[no_mangle]
+        pub extern "C" fn $changed(
+            styleset: &PerDocumentStyleData,
+            rule: &$maybe_locked_rule_type,
+            sheet: &DomStyleSheet,
+            change_kind: RuleChangeKind,
+        ) {
+            let mut data = styleset.borrow_mut();
+            let data = &mut *data;
+            let global_style_data = &*GLOBAL_STYLE_DATA;
+            let guard = global_style_data.shared_lock.read();
+            // TODO(emilio): Would be nice not to deal with refcount bumps here,
+            // but it's probably not a huge deal.
+            let rule = unsafe { CssRule::$name(Arc::from_raw_addrefed(rule)) };
+            let sheet = unsafe { GeckoStyleSheet::new(sheet) };
+            data.stylist.rule_changed(&sheet, &rule, &guard, change_kind);
+        }
+
+        impl_basic_rule_funcs_without_getter! {
+            ($rule_type, $maybe_locked_rule_type),
+            debug: $debug,
+            to_css: $to_css,
+        }
+    }
+}
+
+macro_rules! impl_group_rule_funcs {
+    { ($name:ident, $rule_type:ty, $maybe_locked_rule_type:ty),
+      get_rules: $get_rules:ident,
+      $($basic:tt)+
+    } => {
+        impl_basic_rule_funcs! { ($name, $rule_type, $maybe_locked_rule_type), $($basic)+ }
+
+        #[no_mangle]
+        pub extern "C" fn $get_rules(rule: &$maybe_locked_rule_type) -> Strong<LockedCssRules> {
+            let global_style_data = &*GLOBAL_STYLE_DATA;
+            let guard = global_style_data.shared_lock.read();
+            let rule: &$rule_type = rule.maybe_locked_read(&guard);
+            rule.rules.clone().into()
+        }
+    }
+}
+
+impl_basic_rule_funcs! { (Style, StyleRule, Locked<StyleRule>),
+    getter: Servo_CssRules_GetStyleRuleAt,
+    debug: Servo_StyleRule_Debug,
+    to_css: Servo_StyleRule_GetCssText,
+    changed: Servo_StyleSet_StyleRuleChanged,
+}
+
+impl_basic_rule_funcs! { (Import, ImportRule, Locked<ImportRule>),
+    getter: Servo_CssRules_GetImportRuleAt,
+    debug: Servo_ImportRule_Debug,
+    to_css: Servo_ImportRule_GetCssText,
+    changed: Servo_StyleSet_ImportRuleChanged,
+}
+
+impl_basic_rule_funcs_without_getter! { (Keyframe, Locked<Keyframe>),
+    debug: Servo_Keyframe_Debug,
+    to_css: Servo_Keyframe_GetCssText,
+}
+
+impl_basic_rule_funcs! { (Keyframes, KeyframesRule, Locked<KeyframesRule>),
+    getter: Servo_CssRules_GetKeyframesRuleAt,
+    debug: Servo_KeyframesRule_Debug,
+    to_css: Servo_KeyframesRule_GetCssText,
+    changed: Servo_StyleSet_KeyframesRuleChanged,
+}
+
+impl_group_rule_funcs! { (Media, MediaRule, MediaRule),
+    get_rules: Servo_MediaRule_GetRules,
+    getter: Servo_CssRules_GetMediaRuleAt,
+    debug: Servo_MediaRule_Debug,
+    to_css: Servo_MediaRule_GetCssText,
+    changed: Servo_StyleSet_MediaRuleChanged,
+}
+
+impl_basic_rule_funcs! { (Namespace, NamespaceRule, NamespaceRule),
+    getter: Servo_CssRules_GetNamespaceRuleAt,
+    debug: Servo_NamespaceRule_Debug,
+    to_css: Servo_NamespaceRule_GetCssText,
+    changed: Servo_StyleSet_NamespaceRuleChanged,
+}
+
+impl_basic_rule_funcs! { (Page, PageRule, Locked<PageRule>),
+    getter: Servo_CssRules_GetPageRuleAt,
+    debug: Servo_PageRule_Debug,
+    to_css: Servo_PageRule_GetCssText,
+    changed: Servo_StyleSet_PageRuleChanged,
+}
+
+impl_basic_rule_funcs! { (Property, PropertyRule, PropertyRule),
+    getter: Servo_CssRules_GetPropertyRuleAt,
+    debug: Servo_PropertyRule_Debug,
+    to_css: Servo_PropertyRule_GetCssText,
+    changed: Servo_StyleSet_PropertyRuleChanged,
+}
+
+impl_group_rule_funcs! { (Supports, SupportsRule, SupportsRule),
+    get_rules: Servo_SupportsRule_GetRules,
+    getter: Servo_CssRules_GetSupportsRuleAt,
+    debug: Servo_SupportsRule_Debug,
+    to_css: Servo_SupportsRule_GetCssText,
+    changed: Servo_StyleSet_SupportsRuleChanged,
+}
+
+impl_group_rule_funcs! { (Container, ContainerRule, ContainerRule),
+    get_rules: Servo_ContainerRule_GetRules,
+    getter: Servo_CssRules_GetContainerRuleAt,
+    debug: Servo_ContainerRule_Debug,
+    to_css: Servo_ContainerRule_GetCssText,
+    changed: Servo_StyleSet_ContainerRuleChanged,
+}
+
+impl_group_rule_funcs! { (LayerBlock, LayerBlockRule, LayerBlockRule),
+    get_rules: Servo_LayerBlockRule_GetRules,
+    getter: Servo_CssRules_GetLayerBlockRuleAt,
+    debug: Servo_LayerBlockRule_Debug,
+    to_css: Servo_LayerBlockRule_GetCssText,
+    changed: Servo_StyleSet_LayerBlockRuleChanged,
+}
+
+impl_basic_rule_funcs! { (LayerStatement, LayerStatementRule, LayerStatementRule),
+    getter: Servo_CssRules_GetLayerStatementRuleAt,
+    debug: Servo_LayerStatementRule_Debug,
+    to_css: Servo_LayerStatementRule_GetCssText,
+    changed: Servo_StyleSet_LayerStatementRuleChanged,
+}
+
+impl_group_rule_funcs! { (Document, DocumentRule, DocumentRule),
+    get_rules: Servo_DocumentRule_GetRules,
+    getter: Servo_CssRules_GetDocumentRuleAt,
+    debug: Servo_DocumentRule_Debug,
+    to_css: Servo_DocumentRule_GetCssText,
+    changed: Servo_StyleSet_DocumentRuleChanged,
+}
+
+impl_basic_rule_funcs! { (FontFeatureValues, FontFeatureValuesRule, FontFeatureValuesRule),
+    getter: Servo_CssRules_GetFontFeatureValuesRuleAt,
+    debug: Servo_FontFeatureValuesRule_Debug,
+    to_css: Servo_FontFeatureValuesRule_GetCssText,
+    changed: Servo_StyleSet_FontFeatureValuesRuleChanged,
+}
+
+impl_basic_rule_funcs! { (FontPaletteValues, FontPaletteValuesRule, FontPaletteValuesRule),
+    getter: Servo_CssRules_GetFontPaletteValuesRuleAt,
+    debug: Servo_FontPaletteValuesRule_Debug,
+    to_css: Servo_FontPaletteValuesRule_GetCssText,
+    changed: Servo_StyleSet_FontPaletteValuesRuleChanged,
+}
+
+impl_basic_rule_funcs! { (FontFace, FontFaceRule, Locked<FontFaceRule>),
+    getter: Servo_CssRules_GetFontFaceRuleAt,
+    debug: Servo_FontFaceRule_Debug,
+    to_css: Servo_FontFaceRule_GetCssText,
+    changed: Servo_StyleSet_FontFaceRuleChanged,
+}
+
+impl_basic_rule_funcs! { (CounterStyle, CounterStyleRule, Locked<CounterStyleRule>),
+    getter: Servo_CssRules_GetCounterStyleRuleAt,
+    debug: Servo_CounterStyleRule_Debug,
+    to_css: Servo_CounterStyleRule_GetCssText,
+    changed: Servo_StyleSet_CounterStyleRuleChanged,
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleRule_GetStyle(
+    rule: &LockedStyleRule,
+) -> Strong<LockedDeclarationBlock> {
+    read_locked_arc(rule, |rule: &StyleRule| rule.block.clone().into())
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleRule_SetStyle(
+    rule: &LockedStyleRule,
+    declarations: &LockedDeclarationBlock,
+) {
+    write_locked_arc(rule, |rule: &mut StyleRule| {
+        rule.block = unsafe { Arc::from_raw_addrefed(declarations) };
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleRule_GetSelectorText(rule: &LockedStyleRule, result: &mut nsACString) {
+    read_locked_arc(rule, |rule: &StyleRule| {
+        rule.selectors.to_css(result).unwrap();
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleRule_GetSelectorTextAtIndex(
+    rule: &LockedStyleRule,
+    index: u32,
+    result: &mut nsACString,
+) {
+    read_locked_arc(rule, |rule: &StyleRule| {
+        let index = index as usize;
+        if index >= rule.selectors.0.len() {
+            return;
+        }
+        rule.selectors.0[index].to_css(result).unwrap();
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleRule_GetSelectorCount(rule: &LockedStyleRule, count: *mut u32) {
+    read_locked_arc(rule, |rule: &StyleRule| {
+        *unsafe { count.as_mut().unwrap() } = rule.selectors.0.len() as u32;
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleRule_GetSpecificityAtIndex(
+    rule: &LockedStyleRule,
+    index: u32,
+    specificity: *mut u64,
+) {
+    read_locked_arc(rule, |rule: &StyleRule| {
+        let specificity = unsafe { specificity.as_mut().unwrap() };
+        let index = index as usize;
+        if index >= rule.selectors.0.len() {
+            *specificity = 0;
+            return;
+        }
+        *specificity = rule.selectors.0[index].specificity() as u64;
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleRule_SelectorMatchesElement(
+    rule: &LockedStyleRule,
+    element: &RawGeckoElement,
+    index: u32,
+    pseudo_type: PseudoStyleType,
+    relevant_link_visited: bool,
+) -> bool {
+    use selectors::matching::{
+        matches_selector, MatchingContext, MatchingMode, NeedsSelectorFlags, VisitedHandlingMode,
+    };
+    read_locked_arc(rule, |rule: &StyleRule| {
+        let index = index as usize;
+        if index >= rule.selectors.0.len() {
+            return false;
+        }
+
+        let selector = &rule.selectors.0[index];
+        let mut matching_mode = MatchingMode::Normal;
+
+        match PseudoElement::from_pseudo_type(pseudo_type) {
+            Some(pseudo) => {
+                // We need to make sure that the requested pseudo element type
+                // matches the selector pseudo element type before proceeding.
+                match selector.pseudo_element() {
+                    Some(selector_pseudo) if *selector_pseudo == pseudo => {
+                        matching_mode = MatchingMode::ForStatelessPseudoElement
+                    },
+                    _ => return false,
+                };
+            },
+            None => {
+                // Do not attempt to match if a pseudo element is requested and
+                // this is not a pseudo element selector, or vice versa.
+                if selector.has_pseudo_element() {
+                    return false;
+                }
+            },
+        };
+
+        let element = GeckoElement(element);
+        let quirks_mode = element.as_node().owner_doc().quirks_mode();
+        let mut nth_index_cache = Default::default();
+        let visited_mode = if relevant_link_visited {
+            VisitedHandlingMode::RelevantLinkVisited
+        } else {
+            VisitedHandlingMode::AllLinksUnvisited
+        };
+        let mut ctx = MatchingContext::new_for_visited(
+            matching_mode,
+            None,
+            &mut nth_index_cache,
+            visited_mode,
+            quirks_mode,
+            NeedsSelectorFlags::No,
+        );
+        matches_selector(selector, 0, None, &element, &mut ctx)
+    })
+}
+
+pub type SelectorList = selectors::SelectorList<style::gecko::selector_parser::SelectorImpl>;
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleRule_SetSelectorText(
+    contents: &StylesheetContents,
+    rule: &LockedStyleRule,
+    text: &nsACString,
+) -> bool {
+    let value_str = unsafe { text.as_str_unchecked() };
+
+    write_locked_arc(rule, |rule: &mut StyleRule| {
+        use style::selector_parser::SelectorParser;
+
+        let namespaces = contents.namespaces.read();
+        let url_data = contents.url_data.read();
+        let parser = SelectorParser {
+            stylesheet_origin: contents.origin,
+            namespaces: &namespaces,
+            url_data: &url_data,
+            for_supports_rule: false,
+        };
+
+        let mut parser_input = ParserInput::new(&value_str);
+        match SelectorList::parse(&parser, &mut Parser::new(&mut parser_input)) {
+            Ok(selectors) => {
+                rule.selectors = selectors;
+                true
+            },
+            Err(_) => false,
+        }
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_SelectorList_Closest(
+    element: &RawGeckoElement,
+    selectors: &SelectorList,
+) -> *const RawGeckoElement {
+    use style::dom_apis;
+
+    let element = GeckoElement(element);
+    let quirks_mode = element.as_node().owner_doc().quirks_mode();
+    dom_apis::element_closest(element, &selectors, quirks_mode).map_or(ptr::null(), |e| e.0)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_SelectorList_Matches(
+    element: &RawGeckoElement,
+    selectors: &SelectorList,
+) -> bool {
+    use style::dom_apis;
+
+    let element = GeckoElement(element);
+    let quirks_mode = element.as_node().owner_doc().quirks_mode();
+    dom_apis::element_matches(&element, &selectors, quirks_mode)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_SelectorList_QueryFirst(
+    node: &RawGeckoNode,
+    selectors: &SelectorList,
+    may_use_invalidation: bool,
+) -> *const RawGeckoElement {
+    use style::dom_apis::{self, MayUseInvalidation, QueryFirst};
+
+    let node = GeckoNode(node);
+    let mut result = None;
+
+    let may_use_invalidation = if may_use_invalidation {
+        MayUseInvalidation::Yes
+    } else {
+        MayUseInvalidation::No
+    };
+
+    dom_apis::query_selector::<GeckoElement, QueryFirst>(
+        node,
+        &selectors,
+        &mut result,
+        may_use_invalidation,
+    );
+
+    result.map_or(ptr::null(), |e| e.0)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_SelectorList_QueryAll(
+    node: &RawGeckoNode,
+    selectors: &SelectorList,
+    content_list: *mut structs::nsSimpleContentList,
+    may_use_invalidation: bool,
+) {
+    use style::dom_apis::{self, MayUseInvalidation, QueryAll};
+
+    let node = GeckoNode(node);
+    let mut result = SmallVec::new();
+
+    let may_use_invalidation = if may_use_invalidation {
+        MayUseInvalidation::Yes
+    } else {
+        MayUseInvalidation::No
+    };
+
+    dom_apis::query_selector::<GeckoElement, QueryAll>(
+        node,
+        &selectors,
+        &mut result,
+        may_use_invalidation,
+    );
+
+    if !result.is_empty() {
+        // NOTE(emilio): This relies on a slice of GeckoElement having the same
+        // memory representation than a slice of element pointers.
+        bindings::Gecko_ContentList_AppendAll(
+            content_list,
+            result.as_ptr() as *mut *const _,
+            result.len(),
+        )
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ImportRule_GetHref(rule: &LockedImportRule, result: &mut nsAString) {
+    read_locked_arc(rule, |rule: &ImportRule| {
+        write!(result, "{}", rule.url.as_str()).unwrap();
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ImportRule_GetLayerName(rule: &LockedImportRule, result: &mut nsACString) {
+    // https://w3c.github.io/csswg-drafts/cssom/#dom-cssimportrule-layername
+    read_locked_arc(rule, |rule: &ImportRule| match rule.layer {
+        ImportLayer::Named(ref name) => name.to_css(&mut CssWriter::new(result)).unwrap(), // "return the layer name declared in the at-rule itself"
+        ImportLayer::Anonymous => {}, // "or an empty string if the layer is anonymous"
+        ImportLayer::None => result.set_is_void(true), // "or null if the at-rule does not declare a layer"
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ImportRule_GetSupportsText(
+    rule: &LockedImportRule,
+    result: &mut nsACString,
+) {
+    read_locked_arc(rule, |rule: &ImportRule| match rule.supports {
+        Some(ref supports) => supports
+            .condition
+            .to_css(&mut CssWriter::new(result))
+            .unwrap(),
+        None => result.set_is_void(true),
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ImportRule_GetSheet(rule: &LockedImportRule) -> *const DomStyleSheet {
+    read_locked_arc(rule, |rule: &ImportRule| {
+        rule.stylesheet
+            .as_sheet()
+            .map_or(ptr::null(), |s| s.raw() as *const DomStyleSheet)
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_ImportRule_SetSheet(
+    rule: &LockedImportRule,
+    sheet: *mut DomStyleSheet,
+) {
+    write_locked_arc(rule, |rule: &mut ImportRule| {
+        rule.stylesheet = ImportSheet::new(GeckoStyleSheet::new(sheet));
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_Keyframe_GetKeyText(keyframe: &LockedKeyframe, result: &mut nsACString) {
+    read_locked_arc(keyframe, |keyframe: &Keyframe| {
+        keyframe
+            .selector
+            .to_css(&mut CssWriter::new(result))
+            .unwrap()
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_Keyframe_SetKeyText(keyframe: &LockedKeyframe, text: &nsACString) -> bool {
+    let text = unsafe { text.as_str_unchecked() };
+    let mut input = ParserInput::new(&text);
+    if let Ok(selector) = Parser::new(&mut input).parse_entirely(KeyframeSelector::parse) {
+        write_locked_arc(keyframe, |keyframe: &mut Keyframe| {
+            keyframe.selector = selector;
+        });
+        true
+    } else {
+        false
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_Keyframe_GetStyle(
+    keyframe: &LockedKeyframe,
+) -> Strong<LockedDeclarationBlock> {
+    read_locked_arc(keyframe, |keyframe: &Keyframe| {
+        keyframe.block.clone().into()
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_Keyframe_SetStyle(
+    keyframe: &LockedKeyframe,
+    declarations: &LockedDeclarationBlock,
+) {
+    write_locked_arc(keyframe, |keyframe: &mut Keyframe| {
+        keyframe.block = unsafe { Arc::from_raw_addrefed(declarations) };
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_KeyframesRule_GetName(rule: &LockedKeyframesRule) -> *mut nsAtom {
+    read_locked_arc(rule, |rule: &KeyframesRule| rule.name.as_atom().as_ptr())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_KeyframesRule_SetName(
+    rule: &LockedKeyframesRule,
+    name: *mut nsAtom,
+) {
+    write_locked_arc(rule, |rule: &mut KeyframesRule| {
+        rule.name = KeyframesName::from_atom(Atom::from_addrefed(name));
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_KeyframesRule_GetCount(rule: &LockedKeyframesRule) -> u32 {
+    read_locked_arc(rule, |rule: &KeyframesRule| rule.keyframes.len() as u32)
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_KeyframesRule_GetKeyframeAt(
+    rule: &LockedKeyframesRule,
+    index: u32,
+    line: &mut u32,
+    column: &mut u32,
+) -> Strong<LockedKeyframe> {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    let key = rule.read_with(&guard).keyframes[index as usize].clone();
+    let location = key.read_with(&guard).source_location;
+    *line = location.line as u32;
+    *column = location.column as u32;
+    key.into()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_KeyframesRule_FindRule(
+    rule: &LockedKeyframesRule,
+    key: &nsACString,
+) -> u32 {
+    let key = unsafe { key.as_str_unchecked() };
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    rule.read_with(&guard)
+        .find_rule(&guard, key)
+        .map(|index| index as u32)
+        .unwrap_or(u32::max_value())
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_KeyframesRule_AppendRule(
+    rule: &LockedKeyframesRule,
+    contents: &StylesheetContents,
+    css: &nsACString,
+) -> bool {
+    let css = unsafe { css.as_str_unchecked() };
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+
+    match Keyframe::parse(css, &contents, &global_style_data.shared_lock) {
+        Ok(keyframe) => {
+            write_locked_arc(rule, |rule: &mut KeyframesRule| {
+                rule.keyframes.push(keyframe);
+            });
+            true
+        },
+        Err(..) => false,
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_KeyframesRule_DeleteRule(rule: &LockedKeyframesRule, index: u32) {
+    write_locked_arc(rule, |rule: &mut KeyframesRule| {
+        rule.keyframes.remove(index as usize);
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_MediaRule_GetMedia(rule: &MediaRule) -> Strong<LockedMediaList> {
+    rule.media_queries.clone().into()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_NamespaceRule_GetPrefix(rule: &NamespaceRule) -> *mut nsAtom {
+    rule.prefix
+        .as_ref()
+        .map_or(atom!("").as_ptr(), |a| a.as_ptr())
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_NamespaceRule_GetURI(rule: &NamespaceRule) -> *mut nsAtom {
+    rule.url.0.as_ptr()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_PageRule_GetStyle(rule: &LockedPageRule) -> Strong<LockedDeclarationBlock> {
+    read_locked_arc(rule, |rule: &PageRule| rule.block.clone().into())
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_PageRule_SetStyle(
+    rule: &LockedPageRule,
+    declarations: &LockedDeclarationBlock,
+) {
+    write_locked_arc(rule, |rule: &mut PageRule| {
+        rule.block = unsafe { Arc::from_raw_addrefed(declarations) };
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_PageRule_GetSelectorText(rule: &LockedPageRule, result: &mut nsACString) {
+    read_locked_arc(rule, |rule: &PageRule| {
+        rule.selectors.to_css(&mut CssWriter::new(result)).unwrap();
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_PageRule_SetSelectorText(
+    contents: &StylesheetContents,
+    rule: &LockedPageRule,
+    text: &nsACString,
+) -> bool {
+    let value_str = unsafe { text.as_str_unchecked() };
+
+    write_locked_arc(rule, |rule: &mut PageRule| {
+        use style::stylesheets::PageSelectors;
+
+        let mut parser_input = ParserInput::new(&value_str);
+        let mut parser = Parser::new(&mut parser_input);
+
+        // Ensure that a blank input results in empty page selectors
+        if parser.is_exhausted() {
+            rule.selectors = PageSelectors::default();
+            return true;
+        }
+
+        let url_data = contents.url_data.read();
+        let context = ParserContext::new(
+            Origin::Author,
+            &url_data,
+            None,
+            ParsingMode::DEFAULT,
+            QuirksMode::NoQuirks,
+            /* namespaces = */ Default::default(),
+            None,
+            None,
+        );
+
+        match parser.parse_entirely(|i| PageSelectors::parse(&context, i)) {
+            Ok(selectors) => {
+                rule.selectors = selectors;
+                true
+            },
+            Err(_) => false,
+        }
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_PropertyRule_GetName(rule: &PropertyRule, result: &mut nsACString) {
+    rule.name.to_css(&mut CssWriter::new(result)).unwrap()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_PropertyRule_GetSyntax(rule: &PropertyRule, result: &mut nsACString) {
+    if let Some(ref syntax) = rule.syntax {
+        CssWriter::new(result).write_str(syntax.as_str()).unwrap()
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_PropertyRule_GetInherits(rule: &PropertyRule) -> bool {
+    matches!(rule.inherits, Some(PropertyInherits::True))
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_PropertyRule_GetInitialValue(
+    rule: &PropertyRule,
+    result: &mut nsACString,
+) -> bool {
+    rule.initial_value
+        .to_css(&mut CssWriter::new(result))
+        .unwrap();
+    rule.initial_value.is_some()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_SupportsRule_GetConditionText(
+    rule: &SupportsRule,
+    result: &mut nsACString,
+) {
+    rule.condition.to_css(&mut CssWriter::new(result)).unwrap();
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ContainerRule_GetConditionText(
+    rule: &ContainerRule,
+    result: &mut nsACString,
+) {
+    rule.condition.to_css(&mut CssWriter::new(result)).unwrap();
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ContainerRule_GetContainerQuery(
+    rule: &ContainerRule,
+    result: &mut nsACString,
+) {
+    rule.query_condition()
+        .to_css(&mut CssWriter::new(result))
+        .unwrap();
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ContainerRule_QueryContainerFor(
+    rule: &ContainerRule,
+    element: &RawGeckoElement,
+) -> *const RawGeckoElement {
+    rule.condition
+        .find_container(GeckoElement(element), None)
+        .map_or(ptr::null(), |result| result.element.0)
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ContainerRule_GetContainerName(
+    rule: &ContainerRule,
+    result: &mut nsACString,
+) {
+    let name = rule.container_name();
+    if !name.is_none() {
+        name.to_css(&mut CssWriter::new(result)).unwrap();
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DocumentRule_GetConditionText(
+    rule: &DocumentRule,
+    result: &mut nsACString,
+) {
+    rule.condition.to_css(&mut CssWriter::new(result)).unwrap();
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_FontFeatureValuesRule_GetFontFamily(
+    rule: &FontFeatureValuesRule,
+    result: &mut nsACString,
+) {
+    rule.family_names
+        .to_css(&mut CssWriter::new(result))
+        .unwrap();
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_FontFeatureValuesRule_GetValueText(
+    rule: &FontFeatureValuesRule,
+    result: &mut nsACString,
+) {
+    rule.value_to_css(&mut CssWriter::new(result)).unwrap();
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_FontPaletteValuesRule_GetName(
+    rule: &FontPaletteValuesRule,
+    result: &mut nsACString,
+) {
+    rule.name.to_css(&mut CssWriter::new(result)).unwrap()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_FontPaletteValuesRule_GetFontFamily(
+    rule: &FontPaletteValuesRule,
+    result: &mut nsACString,
+) {
+    if !rule.family_names.is_empty() {
+        rule.family_names
+            .to_css(&mut CssWriter::new(result))
+            .unwrap()
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_FontPaletteValuesRule_GetBasePalette(
+    rule: &FontPaletteValuesRule,
+    result: &mut nsACString,
+) {
+    rule.base_palette
+        .to_css(&mut CssWriter::new(result))
+        .unwrap()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_FontPaletteValuesRule_GetOverrideColors(
+    rule: &FontPaletteValuesRule,
+    result: &mut nsACString,
+) {
+    if !rule.override_colors.is_empty() {
+        rule.override_colors
+            .to_css(&mut CssWriter::new(result))
+            .unwrap()
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_FontFaceRule_CreateEmpty() -> Strong<LockedFontFaceRule> {
+    // XXX This is not great. We should split FontFace descriptor data
+    // from the rule, so that we don't need to create the rule like this
+    // and the descriptor data itself can be hold in UniquePtr from the
+    // Gecko side. See bug 1450904.
+    with_maybe_worker_shared_lock(|lock| {
+        Arc::new(lock.wrap(FontFaceRule::empty(SourceLocation { line: 0, column: 0 }))).into()
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_FontFaceRule_Clone(
+    rule: &LockedFontFaceRule,
+) -> Strong<LockedFontFaceRule> {
+    let clone = read_locked_arc_worker(rule, |rule: &FontFaceRule| rule.clone());
+    with_maybe_worker_shared_lock(|lock| Arc::new(lock.wrap(clone)).into())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_FontFaceRule_GetSourceLocation(
+    rule: &LockedFontFaceRule,
+    line: *mut u32,
+    column: *mut u32,
+) {
+    read_locked_arc_worker(rule, |rule: &FontFaceRule| {
+        let location = rule.source_location;
+        *line.as_mut().unwrap() = location.line as u32;
+        *column.as_mut().unwrap() = location.column as u32;
+    });
+}
+
+macro_rules! apply_font_desc_list {
+    ($apply_macro:ident) => {
+        $apply_macro! {
+            valid: [
+                eCSSFontDesc_Family => family,
+                eCSSFontDesc_Style => style,
+                eCSSFontDesc_Weight => weight,
+                eCSSFontDesc_Stretch => stretch,
+                eCSSFontDesc_Src => sources,
+                eCSSFontDesc_UnicodeRange => unicode_range,
+                eCSSFontDesc_FontFeatureSettings => feature_settings,
+                eCSSFontDesc_FontVariationSettings => variation_settings,
+                eCSSFontDesc_FontLanguageOverride => language_override,
+                eCSSFontDesc_Display => display,
+                eCSSFontDesc_AscentOverride => ascent_override,
+                eCSSFontDesc_DescentOverride => descent_override,
+                eCSSFontDesc_LineGapOverride => line_gap_override,
+                eCSSFontDesc_SizeAdjust => size_adjust,
+            ]
+            invalid: [
+                eCSSFontDesc_UNKNOWN,
+                eCSSFontDesc_COUNT,
+            ]
+        }
+    };
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_FontFaceRule_Length(rule: &LockedFontFaceRule) -> u32 {
+    read_locked_arc_worker(rule, |rule: &FontFaceRule| {
+        let mut result = 0;
+        macro_rules! count_values {
+            (
+                valid: [$($v_enum_name:ident => $field:ident,)*]
+                invalid: [$($i_enum_name:ident,)*]
+            ) => {
+                $(if rule.$field.is_some() {
+                    result += 1;
+                })*
+            }
+        }
+        apply_font_desc_list!(count_values);
+        result
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_FontFaceRule_IndexGetter(
+    rule: &LockedFontFaceRule,
+    index: u32,
+) -> nsCSSFontDesc {
+    read_locked_arc_worker(rule, |rule: &FontFaceRule| {
+        let mut count = 0;
+        macro_rules! lookup_index {
+            (
+                valid: [$($v_enum_name:ident => $field:ident,)*]
+                invalid: [$($i_enum_name:ident,)*]
+            ) => {
+                $(if rule.$field.is_some() {
+                    count += 1;
+                    if count - 1 == index {
+                        return nsCSSFontDesc::$v_enum_name;
+                    }
+                })*
+            }
+        }
+        apply_font_desc_list!(lookup_index);
+        return nsCSSFontDesc::eCSSFontDesc_UNKNOWN;
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_FontFaceRule_GetDeclCssText(
+    rule: &LockedFontFaceRule,
+    result: &mut nsACString,
+) {
+    read_locked_arc_worker(rule, |rule: &FontFaceRule| {
+        rule.decl_to_css(result).unwrap();
+    })
+}
+
+macro_rules! simple_font_descriptor_getter_impl {
+    ($rule:ident, $out:ident, $field:ident, $compute:ident) => {
+        read_locked_arc_worker($rule, |rule: &FontFaceRule| {
+            match rule.$field {
+                None => return false,
+                Some(ref f) => *$out = f.$compute(),
+            }
+            true
+        })
+    };
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_FontFaceRule_GetFontWeight(
+    rule: &LockedFontFaceRule,
+    out: &mut font_face::ComputedFontWeightRange,
+) -> bool {
+    simple_font_descriptor_getter_impl!(rule, out, weight, compute)
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_FontFaceRule_GetFontStretch(
+    rule: &LockedFontFaceRule,
+    out: &mut font_face::ComputedFontStretchRange,
+) -> bool {
+    simple_font_descriptor_getter_impl!(rule, out, stretch, compute)
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_FontFaceRule_GetFontStyle(
+    rule: &LockedFontFaceRule,
+    out: &mut font_face::ComputedFontStyleDescriptor,
+) -> bool {
+    simple_font_descriptor_getter_impl!(rule, out, style, compute)
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_FontFaceRule_GetFontDisplay(
+    rule: &LockedFontFaceRule,
+    out: &mut font_face::FontDisplay,
+) -> bool {
+    simple_font_descriptor_getter_impl!(rule, out, display, clone)
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_FontFaceRule_GetFontLanguageOverride(
+    rule: &LockedFontFaceRule,
+    out: &mut computed::FontLanguageOverride,
+) -> bool {
+    simple_font_descriptor_getter_impl!(rule, out, language_override, clone)
+}
+
+// Returns a Percentage of -1.0 if the override descriptor is present but 'normal'
+// rather than an actual percentage value.
+#[no_mangle]
+pub extern "C" fn Servo_FontFaceRule_GetAscentOverride(
+    rule: &LockedFontFaceRule,
+    out: &mut computed::Percentage,
+) -> bool {
+    simple_font_descriptor_getter_impl!(rule, out, ascent_override, compute)
+}
+
+// Returns a Percentage of -1.0 if the override descriptor is present but 'normal'
+// rather than an actual percentage value.
+#[no_mangle]
+pub extern "C" fn Servo_FontFaceRule_GetDescentOverride(
+    rule: &LockedFontFaceRule,
+    out: &mut computed::Percentage,
+) -> bool {
+    simple_font_descriptor_getter_impl!(rule, out, descent_override, compute)
+}
+
+// Returns a Percentage of -1.0 if the override descriptor is present but 'normal'
+// rather than an actual percentage value.
+#[no_mangle]
+pub extern "C" fn Servo_FontFaceRule_GetLineGapOverride(
+    rule: &LockedFontFaceRule,
+    out: &mut computed::Percentage,
+) -> bool {
+    simple_font_descriptor_getter_impl!(rule, out, line_gap_override, compute)
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_FontFaceRule_GetSizeAdjust(
+    rule: &LockedFontFaceRule,
+    out: &mut computed::Percentage,
+) -> bool {
+    simple_font_descriptor_getter_impl!(rule, out, size_adjust, compute)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_FontFaceRule_GetFamilyName(
+    rule: &LockedFontFaceRule,
+) -> *mut nsAtom {
+    read_locked_arc_worker(rule, |rule: &FontFaceRule| {
+        // TODO(emilio): font-family is a mandatory descriptor, can't we unwrap
+        // here, and remove the null-checks in Gecko?
+        rule.family
+            .as_ref()
+            .map_or(ptr::null_mut(), |f| f.name.as_ptr())
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_FontFaceRule_GetUnicodeRanges(
+    rule: &LockedFontFaceRule,
+    out_len: *mut usize,
+) -> *const UnicodeRange {
+    *out_len = 0;
+    read_locked_arc_worker(rule, |rule: &FontFaceRule| {
+        let ranges = match rule.unicode_range {
+            Some(ref ranges) => ranges,
+            None => return ptr::null(),
+        };
+        *out_len = ranges.len();
+        ranges.as_ptr() as *const _
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_FontFaceRule_GetSources(
+    rule: &LockedFontFaceRule,
+    out: *mut nsTArray<FontFaceSourceListComponent>,
+) {
+    let out = &mut *out;
+    read_locked_arc_worker(rule, |rule: &FontFaceRule| {
+        let sources = match rule.sources {
+            Some(ref s) => s,
+            None => return,
+        };
+        let len = sources.0.iter().fold(0, |acc, src| {
+            acc + match *src {
+                Source::Url(ref url) => {
+                    (if url.format_hint.is_some() { 2 } else { 1 }) +
+                        (if url.tech_flags.is_empty() { 0 } else { 1 })
+                },
+                Source::Local(_) => 1,
+            }
+        });
+
+        out.set_len(len as u32);
+
+        let mut iter = out.iter_mut();
+
+        {
+            let mut set_next = |component: FontFaceSourceListComponent| {
+                *iter.next().expect("miscalculated length") = component;
+            };
+
+            for source in sources.0.iter() {
+                match *source {
+                    Source::Url(ref url) => {
+                        set_next(FontFaceSourceListComponent::Url(&url.url));
+                        if let Some(hint) = &url.format_hint {
+                            match hint {
+                                FontFaceSourceFormat::Keyword(kw) => {
+                                    set_next(FontFaceSourceListComponent::FormatHintKeyword(*kw))
+                                },
+                                FontFaceSourceFormat::String(s) => {
+                                    set_next(FontFaceSourceListComponent::FormatHintString {
+                                        length: s.len(),
+                                        utf8_bytes: s.as_ptr(),
+                                    })
+                                },
+                            }
+                        }
+                        if !url.tech_flags.is_empty() {
+                            set_next(FontFaceSourceListComponent::TechFlags(url.tech_flags));
+                        }
+                    },
+                    Source::Local(ref name) => {
+                        set_next(FontFaceSourceListComponent::Local(name.name.as_ptr()));
+                    },
+                }
+            }
+        }
+
+        assert!(iter.next().is_none(), "miscalculated");
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_FontFaceRule_GetVariationSettings(
+    rule: &LockedFontFaceRule,
+    variations: *mut nsTArray<structs::gfxFontVariation>,
+) {
+    read_locked_arc_worker(rule, |rule: &FontFaceRule| {
+        let source_variations = match rule.variation_settings {
+            Some(ref v) => v,
+            None => return,
+        };
+
+        (*variations).set_len(source_variations.0.len() as u32);
+        for (target, source) in (*variations).iter_mut().zip(source_variations.0.iter()) {
+            *target = structs::gfxFontVariation {
+                mTag: source.tag.0,
+                mValue: source.value.get(),
+            };
+        }
+    });
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_FontFaceRule_GetFeatureSettings(
+    rule: &LockedFontFaceRule,
+    features: *mut nsTArray<structs::gfxFontFeature>,
+) {
+    read_locked_arc_worker(rule, |rule: &FontFaceRule| {
+        let source_features = match rule.feature_settings {
+            Some(ref v) => v,
+            None => return,
+        };
+
+        (*features).set_len(source_features.0.len() as u32);
+        for (target, source) in (*features).iter_mut().zip(source_features.0.iter()) {
+            *target = structs::gfxFontFeature {
+                mTag: source.tag.0,
+                mValue: source.value.value() as u32,
+            };
+        }
+    });
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_FontFaceRule_GetDescriptorCssText(
+    rule: &LockedFontFaceRule,
+    desc: nsCSSFontDesc,
+    result: &mut nsACString,
+) {
+    read_locked_arc_worker(rule, |rule: &FontFaceRule| {
+        let mut writer = CssWriter::new(result);
+        macro_rules! to_css_text {
+            (
+                valid: [$($v_enum_name:ident => $field:ident,)*]
+                invalid: [$($i_enum_name:ident,)*]
+            ) => {
+                match desc {
+                    $(
+                        nsCSSFontDesc::$v_enum_name => {
+                            if let Some(ref value) = rule.$field {
+                                value.to_css(&mut writer).unwrap();
+                            }
+                        }
+                    )*
+                    $(
+                        nsCSSFontDesc::$i_enum_name => {
+                            debug_assert!(false, "not a valid font descriptor");
+                        }
+                    )*
+                }
+            }
+        }
+        apply_font_desc_list!(to_css_text)
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_FontFaceRule_SetDescriptor(
+    rule: &LockedFontFaceRule,
+    desc: nsCSSFontDesc,
+    value: &nsACString,
+    data: *mut URLExtraData,
+    out_changed: *mut bool,
+) -> bool {
+    let value = value.as_str_unchecked();
+    let mut input = ParserInput::new(&value);
+    let mut parser = Parser::new(&mut input);
+    let url_data = UrlExtraData::from_ptr_ref(&data);
+    let context = ParserContext::new(
+        Origin::Author,
+        url_data,
+        Some(CssRuleType::FontFace),
+        ParsingMode::DEFAULT,
+        QuirksMode::NoQuirks,
+        /* namespaces = */ Default::default(),
+        None,
+        None,
+    );
+
+    write_locked_arc_worker(rule, |rule: &mut FontFaceRule| {
+        macro_rules! to_css_text {
+            (
+                valid: [$($v_enum_name:ident => $field:ident,)*]
+                invalid: [$($i_enum_name:ident,)*]
+            ) => {
+                match desc {
+                    $(
+                        nsCSSFontDesc::$v_enum_name => {
+                            if let Ok(value) = parser.parse_entirely(|i| Parse::parse(&context, i)) {
+                                let result = Some(value);
+                                *out_changed = result != rule.$field;
+                                rule.$field = result;
+                                true
+                            } else {
+                                false
+                            }
+                        }
+                    )*
+                    $(
+                        nsCSSFontDesc::$i_enum_name => {
+                            debug_assert!(false, "not a valid font descriptor");
+                            false
+                        }
+                    )*
+                }
+            }
+        }
+        apply_font_desc_list!(to_css_text)
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_FontFaceRule_ResetDescriptor(
+    rule: &LockedFontFaceRule,
+    desc: nsCSSFontDesc,
+) {
+    write_locked_arc_worker(rule, |rule: &mut FontFaceRule| {
+        macro_rules! reset_desc {
+            (
+                valid: [$($v_enum_name:ident => $field:ident,)*]
+                invalid: [$($i_enum_name:ident,)*]
+            ) => {
+                match desc {
+                    $(nsCSSFontDesc::$v_enum_name => rule.$field = None,)*
+                    $(nsCSSFontDesc::$i_enum_name => debug_assert!(false, "not a valid font descriptor"),)*
+                }
+            }
+        }
+        apply_font_desc_list!(reset_desc)
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_CounterStyleRule_GetName(
+    rule: &LockedCounterStyleRule,
+) -> *mut nsAtom {
+    read_locked_arc(rule, |rule: &CounterStyleRule| rule.name().0.as_ptr())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_CounterStyleRule_SetName(
+    rule: &LockedCounterStyleRule,
+    value: &nsACString,
+) -> bool {
+    let value = value.as_str_unchecked();
+    let mut input = ParserInput::new(&value);
+    let mut parser = Parser::new(&mut input);
+    match parser.parse_entirely(counter_style::parse_counter_style_name_definition) {
+        Ok(name) => {
+            write_locked_arc(rule, |rule: &mut CounterStyleRule| rule.set_name(name));
+            true
+        },
+        Err(_) => false,
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_CounterStyleRule_GetGeneration(
+    rule: &LockedCounterStyleRule,
+) -> u32 {
+    read_locked_arc(rule, |rule: &CounterStyleRule| rule.generation())
+}
+
+fn symbol_to_string(s: &counter_style::Symbol) -> nsString {
+    match *s {
+        counter_style::Symbol::String(ref s) => nsString::from(&**s),
+        counter_style::Symbol::Ident(ref i) => nsString::from(i.0.as_slice()),
+    }
+}
+
+// TODO(emilio): Cbindgen could be used to simplify a bunch of code here.
+#[no_mangle]
+pub unsafe extern "C" fn Servo_CounterStyleRule_GetPad(
+    rule: &LockedCounterStyleRule,
+    width: &mut i32,
+    symbol: &mut nsString,
+) -> bool {
+    read_locked_arc(rule, |rule: &CounterStyleRule| {
+        let pad = match rule.pad() {
+            Some(pad) => pad,
+            None => return false,
+        };
+        *width = pad.0.value();
+        *symbol = symbol_to_string(&pad.1);
+        true
+    })
+}
+
+fn get_symbol(s: Option<&counter_style::Symbol>, out: &mut nsString) -> bool {
+    let s = match s {
+        Some(s) => s,
+        None => return false,
+    };
+    *out = symbol_to_string(s);
+    true
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_CounterStyleRule_GetPrefix(
+    rule: &LockedCounterStyleRule,
+    out: &mut nsString,
+) -> bool {
+    read_locked_arc(rule, |rule: &CounterStyleRule| {
+        get_symbol(rule.prefix(), out)
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_CounterStyleRule_GetSuffix(
+    rule: &LockedCounterStyleRule,
+    out: &mut nsString,
+) -> bool {
+    read_locked_arc(rule, |rule: &CounterStyleRule| {
+        get_symbol(rule.suffix(), out)
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_CounterStyleRule_GetNegative(
+    rule: &LockedCounterStyleRule,
+    prefix: &mut nsString,
+    suffix: &mut nsString,
+) -> bool {
+    read_locked_arc(rule, |rule: &CounterStyleRule| {
+        let negative = match rule.negative() {
+            Some(n) => n,
+            None => return false,
+        };
+        *prefix = symbol_to_string(&negative.0);
+        *suffix = match negative.1 {
+            Some(ref s) => symbol_to_string(s),
+            None => nsString::new(),
+        };
+        true
+    })
+}
+
+#[repr(u8)]
+pub enum IsOrdinalInRange {
+    Auto,
+    InRange,
+    NotInRange,
+    NoOrdinalSpecified,
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_CounterStyleRule_IsInRange(
+    rule: &LockedCounterStyleRule,
+    ordinal: i32,
+) -> IsOrdinalInRange {
+    use style::counter_style::CounterBound;
+    read_locked_arc(rule, |rule: &CounterStyleRule| {
+        let range = match rule.range() {
+            Some(r) => r,
+            None => return IsOrdinalInRange::NoOrdinalSpecified,
+        };
+
+        if range.0.is_empty() {
+            return IsOrdinalInRange::Auto;
+        }
+
+        let in_range = range.0.iter().any(|r| {
+            if let CounterBound::Integer(start) = r.start {
+                if start.value() > ordinal {
+                    return false;
+                }
+            }
+
+            if let CounterBound::Integer(end) = r.end {
+                if end.value() < ordinal {
+                    return false;
+                }
+            }
+
+            true
+        });
+
+        if in_range {
+            IsOrdinalInRange::InRange
+        } else {
+            IsOrdinalInRange::NotInRange
+        }
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_CounterStyleRule_GetSymbols(
+    rule: &LockedCounterStyleRule,
+    symbols: &mut style::OwnedSlice<nsString>,
+) {
+    read_locked_arc(rule, |rule: &CounterStyleRule| {
+        *symbols = match rule.symbols() {
+            Some(s) => s.0.iter().map(symbol_to_string).collect(),
+            None => style::OwnedSlice::default(),
+        };
+    })
+}
+
+#[repr(C)]
+pub struct AdditiveSymbol {
+    pub weight: i32,
+    pub symbol: nsString,
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_CounterStyleRule_GetAdditiveSymbols(
+    rule: &LockedCounterStyleRule,
+    symbols: &mut style::OwnedSlice<AdditiveSymbol>,
+) {
+    read_locked_arc(rule, |rule: &CounterStyleRule| {
+        *symbols = match rule.additive_symbols() {
+            Some(s) => {
+                s.0.iter()
+                    .map(|s| AdditiveSymbol {
+                        weight: s.weight.value(),
+                        symbol: symbol_to_string(&s.symbol),
+                    })
+                    .collect()
+            },
+            None => style::OwnedSlice::default(),
+        };
+    })
+}
+
+#[repr(C, u8)]
+pub enum CounterSpeakAs {
+    None,
+    Auto,
+    Bullets,
+    Numbers,
+    Words,
+    Ident(*mut nsAtom),
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_CounterStyleRule_GetSpeakAs(
+    rule: &LockedCounterStyleRule,
+    out: &mut CounterSpeakAs,
+) {
+    use style::counter_style::SpeakAs;
+    *out = read_locked_arc(rule, |rule: &CounterStyleRule| {
+        let speak_as = match rule.speak_as() {
+            Some(s) => s,
+            None => return CounterSpeakAs::None,
+        };
+        match *speak_as {
+            SpeakAs::Auto => CounterSpeakAs::Auto,
+            SpeakAs::Bullets => CounterSpeakAs::Bullets,
+            SpeakAs::Numbers => CounterSpeakAs::Numbers,
+            SpeakAs::Words => CounterSpeakAs::Words,
+            SpeakAs::Other(ref other) => CounterSpeakAs::Ident(other.0.as_ptr()),
+        }
+    });
+}
+
+#[repr(u8)]
+pub enum CounterSystem {
+    Cyclic = 0,
+    Numeric,
+    Alphabetic,
+    Symbolic,
+    Additive,
+    Fixed,
+    Extends,
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_CounterStyleRule_GetSystem(
+    rule: &LockedCounterStyleRule,
+) -> CounterSystem {
+    use style::counter_style::System;
+    read_locked_arc(rule, |rule: &CounterStyleRule| {
+        match *rule.resolved_system() {
+            System::Cyclic => CounterSystem::Cyclic,
+            System::Numeric => CounterSystem::Numeric,
+            System::Alphabetic => CounterSystem::Alphabetic,
+            System::Symbolic => CounterSystem::Symbolic,
+            System::Additive => CounterSystem::Additive,
+            System::Fixed { .. } => CounterSystem::Fixed,
+            System::Extends(_) => CounterSystem::Extends,
+        }
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_CounterStyleRule_GetExtended(
+    rule: &LockedCounterStyleRule,
+) -> *mut nsAtom {
+    read_locked_arc(rule, |rule: &CounterStyleRule| {
+        match *rule.resolved_system() {
+            counter_style::System::Extends(ref name) => name.0.as_ptr(),
+            _ => {
+                debug_assert!(false, "Not extends system");
+                ptr::null_mut()
+            },
+        }
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_CounterStyleRule_GetFixedFirstValue(
+    rule: &LockedCounterStyleRule,
+) -> i32 {
+    read_locked_arc(rule, |rule: &CounterStyleRule| {
+        match *rule.resolved_system() {
+            counter_style::System::Fixed { first_symbol_value } => {
+                first_symbol_value.map_or(1, |v| v.value())
+            },
+            _ => {
+                debug_assert!(false, "Not fixed system");
+                0
+            },
+        }
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_CounterStyleRule_GetFallback(
+    rule: &LockedCounterStyleRule,
+) -> *mut nsAtom {
+    read_locked_arc(rule, |rule: &CounterStyleRule| {
+        rule.fallback().map_or(ptr::null_mut(), |i| i.0 .0.as_ptr())
+    })
+}
+
+macro_rules! counter_style_descriptors {
+    {
+        valid: [
+            $($desc:ident => $getter:ident / $setter:ident,)+
+        ]
+        invalid: [
+            $($i_desc:ident,)+
+        ]
+    } => {
+        #[no_mangle]
+        pub unsafe extern "C" fn Servo_CounterStyleRule_GetDescriptorCssText(
+            rule: &LockedCounterStyleRule,
+            desc: nsCSSCounterDesc,
+            result: &mut nsACString,
+        ) {
+            let mut writer = CssWriter::new(result);
+            read_locked_arc(rule, |rule: &CounterStyleRule| {
+                match desc {
+                    $(nsCSSCounterDesc::$desc => {
+                        if let Some(value) = rule.$getter() {
+                            value.to_css(&mut writer).unwrap();
+                        }
+                    })+
+                    $(nsCSSCounterDesc::$i_desc => unreachable!(),)+
+                }
+            });
+        }
+
+        #[no_mangle]
+        pub unsafe extern "C" fn Servo_CounterStyleRule_SetDescriptor(
+            rule: &LockedCounterStyleRule,
+            desc: nsCSSCounterDesc,
+            value: &nsACString,
+        ) -> bool {
+            let value = value.as_str_unchecked();
+            let mut input = ParserInput::new(&value);
+            let mut parser = Parser::new(&mut input);
+            let url_data = dummy_url_data();
+            let context = ParserContext::new(
+                Origin::Author,
+                url_data,
+                Some(CssRuleType::CounterStyle),
+                ParsingMode::DEFAULT,
+                QuirksMode::NoQuirks,
+                /* namespaces = */ Default::default(),
+                None,
+                None,
+            );
+
+            write_locked_arc(rule, |rule: &mut CounterStyleRule| {
+                match desc {
+                    $(nsCSSCounterDesc::$desc => {
+                        match parser.parse_entirely(|i| Parse::parse(&context, i)) {
+                            Ok(value) => rule.$setter(value),
+                            Err(_) => false,
+                        }
+                    })+
+                    $(nsCSSCounterDesc::$i_desc => unreachable!(),)+
+                }
+            })
+        }
+    }
+}
+
+counter_style_descriptors! {
+    valid: [
+        eCSSCounterDesc_System => system / set_system,
+        eCSSCounterDesc_Symbols => symbols / set_symbols,
+        eCSSCounterDesc_AdditiveSymbols => additive_symbols / set_additive_symbols,
+        eCSSCounterDesc_Negative => negative / set_negative,
+        eCSSCounterDesc_Prefix => prefix / set_prefix,
+        eCSSCounterDesc_Suffix => suffix / set_suffix,
+        eCSSCounterDesc_Range => range / set_range,
+        eCSSCounterDesc_Pad => pad / set_pad,
+        eCSSCounterDesc_Fallback => fallback / set_fallback,
+        eCSSCounterDesc_SpeakAs => speak_as / set_speak_as,
+    ]
+    invalid: [
+        eCSSCounterDesc_UNKNOWN,
+        eCSSCounterDesc_COUNT,
+    ]
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_ComputedValues_GetForPageContent(
+    raw_data: &PerDocumentStyleData,
+    page_name: *const nsAtom,
+) -> Strong<ComputedValues> {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    let guards = StylesheetGuards::same(&guard);
+    let data = raw_data.borrow_mut();
+
+    let mut extra_declarations = vec![];
+    let iter = data.stylist.iter_extra_data_origins_rev();
+    for (data, origin) in iter {
+        let level = match origin {
+            Origin::UserAgent => CascadeLevel::UANormal,
+            Origin::User => CascadeLevel::UserNormal,
+            Origin::Author => CascadeLevel::same_tree_author_normal(),
+        };
+        extra_declarations.reserve(data.pages.global.len());
+        let mut add_rule = |rule: &Arc<Locked<PageRule>>| {
+            extra_declarations.push(ApplicableDeclarationBlock::from_declarations(
+                rule.read_with(level.guard(&guards)).block.clone(),
+                level,
+                LayerOrder::root(),
+            ));
+        };
+        for &(ref rule, _layer_id) in data.pages.global.iter() {
+            add_rule(&rule.0);
+        }
+        if !page_name.is_null() {
+            Atom::with(page_name, |name| {
+                if let Some(rules) = data.pages.named.get(name) {
+                    // Rules are already sorted by source order.
+                    rules.iter().for_each(|d| add_rule(&d.rule));
+                }
+            });
+        }
+    }
+
+    let rule_node = data.stylist.rule_node_for_precomputed_pseudo(
+        &guards,
+        &PseudoElement::PageContent,
+        extra_declarations,
+    );
+
+    data.stylist
+        .precomputed_values_for_pseudo_with_rule_node::<GeckoElement>(
+            &guards,
+            &PseudoElement::PageContent,
+            None,
+            rule_node,
+        )
+        .into()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_ComputedValues_GetForAnonymousBox(
+    parent_style_or_null: Option<&ComputedValues>,
+    pseudo: PseudoStyleType,
+    raw_data: &PerDocumentStyleData,
+) -> Strong<ComputedValues> {
+    let pseudo = PseudoElement::from_pseudo_type(pseudo).unwrap();
+    debug_assert!(pseudo.is_anon_box());
+    debug_assert_ne!(pseudo, PseudoElement::PageContent);
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    let guards = StylesheetGuards::same(&guard);
+    let data = raw_data.borrow_mut();
+    let rule_node = data
+        .stylist
+        .rule_node_for_precomputed_pseudo(&guards, &pseudo, vec![]);
+
+    data.stylist
+        .precomputed_values_for_pseudo_with_rule_node::<GeckoElement>(
+            &guards,
+            &pseudo,
+            parent_style_or_null.map(|x| &*x),
+            rule_node,
+        )
+        .into()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ResolvePseudoStyle(
+    element: &RawGeckoElement,
+    pseudo_type: PseudoStyleType,
+    is_probe: bool,
+    inherited_style: Option<&ComputedValues>,
+    raw_data: &PerDocumentStyleData,
+) -> Strong<ComputedValues> {
+    let element = GeckoElement(element);
+    let doc_data = raw_data.borrow();
+
+    debug!(
+        "Servo_ResolvePseudoStyle: {:?} {:?}, is_probe: {}",
+        element,
+        PseudoElement::from_pseudo_type(pseudo_type),
+        is_probe
+    );
+
+    let data = element.borrow_data();
+
+    let data = match data.as_ref() {
+        Some(data) if data.has_styles() => data,
+        _ => {
+            // FIXME(bholley, emilio): Assert against this.
+            //
+            // Known offender is nsMathMLmoFrame::MarkIntrinsicISizesDirty,
+            // which goes and does a bunch of work involving style resolution.
+            //
+            // Bug 1403865 tracks fixing it, and potentially adding an assert
+            // here instead.
+            warn!("Calling Servo_ResolvePseudoStyle on unstyled element");
+            return if is_probe {
+                Strong::null()
+            } else {
+                doc_data.default_computed_values().clone().into()
+            };
+        },
+    };
+
+    let pseudo = PseudoElement::from_pseudo_type(pseudo_type)
+        .expect("ResolvePseudoStyle with a non-pseudo?");
+
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    let style = get_pseudo_style(
+        &guard,
+        element,
+        &pseudo,
+        RuleInclusion::All,
+        &data.styles,
+        inherited_style,
+        &doc_data.stylist,
+        is_probe,
+        /* matching_func = */ None,
+    );
+
+    match style {
+        Some(s) => s.into(),
+        None => {
+            debug_assert!(is_probe);
+            Strong::null()
+        },
+    }
+}
+
+fn debug_atom_array(atoms: &nsTArray<structs::RefPtr<nsAtom>>) -> String {
+    let mut result = String::from("[");
+    for atom in atoms.iter() {
+        if atom.mRawPtr.is_null() {
+            result += "(null), ";
+        } else {
+            let atom = unsafe { WeakAtom::new(atom.mRawPtr) };
+            write!(result, "{}, ", atom).unwrap();
+        }
+    }
+    result.push(']');
+    result
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ComputedValues_ResolveHighlightPseudoStyle(
+    element: &RawGeckoElement,
+    highlight_name: *const nsAtom,
+    raw_data: &PerDocumentStyleData,
+) -> Strong<ComputedValues> {
+    let element = GeckoElement(element);
+    let data = element
+        .borrow_data()
+        .expect("Calling ResolveHighlightPseudoStyle on unstyled element?");
+    let pseudo_element = unsafe {
+        AtomIdent::with(highlight_name, |atom| {
+            PseudoElement::Highlight(atom.to_owned())
+        })
+    };
+
+    let doc_data = raw_data.borrow();
+
+    let matching_fn = |pseudo: &PseudoElement| *pseudo == pseudo_element;
+
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    let style = get_pseudo_style(
+        &guard,
+        element,
+        &pseudo_element,
+        RuleInclusion::All,
+        &data.styles,
+        None,
+        &doc_data.stylist,
+        /* is_probe = */ true,
+        Some(&matching_fn),
+    );
+    match style {
+        Some(s) => s.into(),
+        None => Strong::null(),
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ComputedValues_ResolveXULTreePseudoStyle(
+    element: &RawGeckoElement,
+    pseudo_tag: *mut nsAtom,
+    inherited_style: &ComputedValues,
+    input_word: &nsTArray<structs::RefPtr<nsAtom>>,
+    raw_data: &PerDocumentStyleData,
+) -> Strong<ComputedValues> {
+    let element = GeckoElement(element);
+    let data = element
+        .borrow_data()
+        .expect("Calling ResolveXULTreePseudoStyle on unstyled element?");
+
+    let pseudo = unsafe {
+        Atom::with(pseudo_tag, |atom| {
+            PseudoElement::from_tree_pseudo_atom(atom, Box::new([]))
+        })
+        .expect("ResolveXULTreePseudoStyle with a non-tree pseudo?")
+    };
+    let doc_data = raw_data.borrow();
+
+    debug!(
+        "ResolveXULTreePseudoStyle: {:?} {:?} {}",
+        element,
+        pseudo,
+        debug_atom_array(input_word)
+    );
+
+    let matching_fn = |pseudo: &PseudoElement| {
+        let args = pseudo
+            .tree_pseudo_args()
+            .expect("Not a tree pseudo-element?");
+        args.iter()
+            .all(|atom| input_word.iter().any(|item| atom.as_ptr() == item.mRawPtr))
+    };
+
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    get_pseudo_style(
+        &guard,
+        element,
+        &pseudo,
+        RuleInclusion::All,
+        &data.styles,
+        Some(inherited_style),
+        &doc_data.stylist,
+        /* is_probe = */ false,
+        Some(&matching_fn),
+    )
+    .unwrap()
+    .into()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_SetExplicitStyle(element: &RawGeckoElement, style: &ComputedValues) {
+    let element = GeckoElement(element);
+    debug!("Servo_SetExplicitStyle: {:?}", element);
+    // We only support this API for initial styling. There's no reason it couldn't
+    // work for other things, we just haven't had a reason to do so.
+    debug_assert!(!element.has_data());
+    let mut data = unsafe { element.ensure_data() };
+    data.styles.primary = Some(unsafe { Arc::from_raw_addrefed(style) });
+}
+
+fn get_pseudo_style(
+    guard: &SharedRwLockReadGuard,
+    element: GeckoElement,
+    pseudo: &PseudoElement,
+    rule_inclusion: RuleInclusion,
+    styles: &ElementStyles,
+    inherited_styles: Option<&ComputedValues>,
+    stylist: &Stylist,
+    is_probe: bool,
+    matching_func: Option<&dyn Fn(&PseudoElement) -> bool>,
+) -> Option<Arc<ComputedValues>> {
+    let style = match pseudo.cascade_type() {
+        PseudoElementCascadeType::Eager => {
+            match *pseudo {
+                PseudoElement::FirstLetter => {
+                    styles.pseudos.get(&pseudo).map(|pseudo_styles| {
+                        // inherited_styles can be None when doing lazy resolution
+                        // (e.g. for computed style) or when probing.  In that case
+                        // we just inherit from our element, which is what Gecko
+                        // does in that situation.  What should actually happen in
+                        // the computed style case is a bit unclear.
+                        let inherited_styles = inherited_styles.unwrap_or(styles.primary());
+                        let guards = StylesheetGuards::same(guard);
+                        let inputs = CascadeInputs::new_from_style(pseudo_styles);
+                        stylist.compute_pseudo_element_style_with_inputs(
+                            inputs,
+                            pseudo,
+                            &guards,
+                            Some(styles.primary()),
+                            Some(inherited_styles),
+                            Some(element),
+                        )
+                    })
+                },
+                _ => {
+                    // Unfortunately, we can't assert that inherited_styles, if
+                    // present, is pointer-equal to styles.primary(), or even
+                    // equal in any meaningful way.  The way it can fail is as
+                    // follows.  Say we append an element with a ::before,
+                    // ::after, or ::first-line to a parent with a ::first-line,
+                    // such that the element ends up on the first line of the
+                    // parent (e.g. it's an inline-block in the case it has a
+                    // ::first-line, or any container in the ::before/::after
+                    // cases).  Then gecko will update its frame's style to
+                    // inherit from the parent's ::first-line.  The next time we
+                    // try to get the ::before/::after/::first-line style for
+                    // the kid, we'll likely pass in the frame's style as
+                    // inherited_styles, but that's not pointer-identical to
+                    // styles.primary(), because it got reparented.
+                    //
+                    // Now in practice this turns out to be OK, because all the
+                    // cases in which there's a mismatch go ahead and reparent
+                    // styles again as needed to make sure the ::first-line
+                    // affects all the things it should affect.  But it makes it
+                    // impossible to assert anything about the two styles
+                    // matching here, unfortunately.
+                    styles.pseudos.get(&pseudo).cloned()
+                },
+            }
+        },
+        PseudoElementCascadeType::Precomputed => unreachable!("No anonymous boxes"),
+        PseudoElementCascadeType::Lazy => {
+            debug_assert!(
+                inherited_styles.is_none() ||
+                    ptr::eq(inherited_styles.unwrap(), &**styles.primary())
+            );
+            let base = if pseudo.inherits_from_default_values() {
+                stylist.device().default_computed_values_arc()
+            } else {
+                styles.primary()
+            };
+            let guards = StylesheetGuards::same(guard);
+            stylist.lazily_compute_pseudo_element_style(
+                &guards,
+                element,
+                &pseudo,
+                rule_inclusion,
+                styles.primary(),
+                base,
+                is_probe,
+                matching_func,
+            )
+        },
+    };
+
+    if is_probe {
+        return style;
+    }
+
+    Some(style.unwrap_or_else(|| {
+        StyleBuilder::for_inheritance(stylist.device(), Some(styles.primary()), Some(pseudo))
+            .build()
+    }))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_ComputedValues_Inherit(
+    raw_data: &PerDocumentStyleData,
+    pseudo: PseudoStyleType,
+    parent_style_context: Option<&ComputedValues>,
+    target: structs::InheritTarget,
+) -> Strong<ComputedValues> {
+    let data = raw_data.borrow();
+
+    let for_text = target == structs::InheritTarget::Text;
+    let pseudo = PseudoElement::from_pseudo_type(pseudo).unwrap();
+    debug_assert!(pseudo.is_anon_box());
+
+    let mut style =
+        StyleBuilder::for_inheritance(data.stylist.device(), parent_style_context, Some(&pseudo));
+
+    if for_text {
+        StyleAdjuster::new(&mut style).adjust_for_text();
+    }
+
+    style.build().into()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ComputedValues_SpecifiesAnimationsOrTransitions(
+    values: &ComputedValues,
+) -> bool {
+    let ui = values.get_ui();
+    ui.specifies_animations() || ui.specifies_transitions()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ComputedValues_GetStyleRuleList(
+    values: &ComputedValues,
+    rules: &mut ThinVec<*const LockedStyleRule>,
+) {
+    let rule_node = match values.rules {
+        Some(ref r) => r,
+        None => return,
+    };
+
+    for node in rule_node.self_and_ancestors() {
+        let style_rule = match node.style_source().and_then(|x| x.as_rule()) {
+            Some(rule) => rule,
+            _ => continue,
+        };
+
+        // For the rules with any important declaration, we insert them into
+        // rule tree twice, one for normal level and another for important
+        // level. So, we skip the important one to keep the specificity order of
+        // rules.
+        if node.importance().important() {
+            continue;
+        }
+
+        rules.push(&*style_rule);
+    }
+}
+
+/// println_stderr!() calls Gecko's printf_stderr(), which, unlike eprintln!(),
+/// will funnel output to Android logcat.
+#[cfg(feature = "gecko_debug")]
+macro_rules! println_stderr {
+    ($($e:expr),+) => {
+        {
+            let mut s = nsCString::new();
+            write!(s, $($e),+).unwrap();
+            s.write_char('\n').unwrap();
+            unsafe { bindings::Gecko_PrintfStderr(&s); }
+        }
+    }
+}
+
+#[cfg(feature = "gecko_debug")]
+fn dump_properties_and_rules(cv: &ComputedValues, properties: &LonghandIdSet) {
+    println_stderr!("  Properties:");
+    for p in properties.iter() {
+        let mut v = nsCString::new();
+        cv.computed_or_resolved_value(p, None, &mut v).unwrap();
+        println_stderr!("    {:?}: {}", p, v);
+    }
+    dump_rules(cv);
+}
+
+#[cfg(feature = "gecko_debug")]
+fn dump_rules(cv: &ComputedValues) {
+    println_stderr!("  Rules({:?}):", cv.pseudo());
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    if let Some(rules) = cv.rules.as_ref() {
+        for rn in rules.self_and_ancestors() {
+            if rn.importance().important() {
+                continue;
+            }
+            if let Some(d) = rn.style_source().and_then(|s| s.as_declarations()) {
+                println_stderr!("    [DeclarationBlock: {:?}]", d);
+            }
+            if let Some(r) = rn.style_source().and_then(|s| s.as_rule()) {
+                let mut s = nsCString::new();
+                r.read_with(&guard).to_css(&guard, &mut s).unwrap();
+                println_stderr!("    {}", s);
+            }
+        }
+    }
+}
+
+#[cfg(feature = "gecko_debug")]
+#[no_mangle]
+pub extern "C" fn Servo_ComputedValues_EqualForCachedAnonymousContentStyle(
+    a: &ComputedValues,
+    b: &ComputedValues,
+) -> bool {
+    let mut differing_properties = a.differing_properties(b);
+
+    // Ignore any difference in -x-lang, which we can't override in the rules in scrollbars.css,
+    // but which makes no difference for the anonymous content subtrees we cache style for.
+    differing_properties.remove(LonghandId::XLang);
+    // Similarly, -x-lang can influence the font-family fallback we have for the initial
+    // font-family so remove it as well.
+    differing_properties.remove(LonghandId::FontFamily);
+
+    // Ignore any difference in pref-controlled, inherited properties.  These properties may or may
+    // not be set by the 'all' declaration in scrollbars.css, depending on whether the pref was
+    // enabled at the time the UA sheets were parsed.
+    //
+    // If you add a new pref-controlled, inherited property, it must be defined with
+    // `has_effect_on_gecko_scrollbars=False` to declare that different values of this property on
+    // a <scrollbar> element or its descendant scrollbar part elements should have no effect on
+    // their rendering and behavior.
+    //
+    // If you do need a pref-controlled, inherited property to have an effect on these elements,
+    // then you will need to add some checks to the
+    // nsIAnonymousContentCreator::CreateAnonymousContent implementations of nsHTMLScrollFrame and
+    // nsScrollbarFrame to clear the AnonymousContentKey if a non-initial value is used.
+    differing_properties.remove_all(&LonghandIdSet::has_no_effect_on_gecko_scrollbars());
+
+    if !differing_properties.is_empty() {
+        println_stderr!("Actual style:");
+        dump_properties_and_rules(a, &differing_properties);
+        println_stderr!("Expected style:");
+        dump_properties_and_rules(b, &differing_properties);
+    }
+
+    differing_properties.is_empty()
+}
+
+#[cfg(feature = "gecko_debug")]
+#[no_mangle]
+pub extern "C" fn Servo_ComputedValues_DumpMatchedRules(s: &ComputedValues) {
+    dump_rules(s);
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ComputedValues_BlockifiedDisplay(
+    style: &ComputedValues,
+    is_root_element: bool,
+) -> u16 {
+    let display = style.get_box().clone_display();
+    let blockified_display = display.equivalent_block_display(is_root_element);
+    blockified_display.to_u16()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_Init(doc: &structs::Document) -> *mut PerDocumentStyleData {
+    let data = Box::new(PerDocumentStyleData::new(doc));
+
+    // Do this here rather than in Servo_Initialize since we need a document to
+    // get the default computed values from.
+    style::properties::generated::gecko::assert_initial_values_match(&data);
+
+    Box::into_raw(data) as *mut PerDocumentStyleData
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_StyleSet_Drop(data: *mut PerDocumentStyleData) {
+    let _ = Box::from_raw(data);
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_RebuildCachedData(raw_data: &PerDocumentStyleData) {
+    let mut data = raw_data.borrow_mut();
+    data.stylist.device_mut().rebuild_cached_data();
+    data.undisplayed_style_cache.clear();
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_StyleSet_CompatModeChanged(raw_data: &PerDocumentStyleData) {
+    let mut data = raw_data.borrow_mut();
+    let quirks_mode = data.stylist.device().document().mCompatMode;
+    data.stylist.set_quirks_mode(quirks_mode.into());
+}
+
+fn parse_property_into(
+    declarations: &mut SourcePropertyDeclaration,
+    property_id: PropertyId,
+    value: &nsACString,
+    origin: Origin,
+    url_data: &UrlExtraData,
+    parsing_mode: structs::ParsingMode,
+    quirks_mode: QuirksMode,
+    rule_type: CssRuleType,
+    reporter: Option<&dyn ParseErrorReporter>,
+) -> Result<(), ()> {
+    let value = unsafe { value.as_str_unchecked() };
+    let parsing_mode = ParsingMode::from_bits_retain(parsing_mode);
+
+    if let Some(non_custom) = property_id.non_custom_id() {
+        if !non_custom.allowed_in_rule(rule_type.into()) {
+            return Err(());
+        }
+    }
+
+    parse_one_declaration_into(
+        declarations,
+        property_id,
+        value,
+        origin,
+        url_data,
+        reporter,
+        parsing_mode,
+        quirks_mode,
+        rule_type,
+    )
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_ParseProperty(
+    property: nsCSSPropertyID,
+    value: &nsACString,
+    data: *mut URLExtraData,
+    parsing_mode: structs::ParsingMode,
+    quirks_mode: nsCompatibility,
+    loader: *mut Loader,
+    rule_type: CssRuleType,
+) -> Strong<LockedDeclarationBlock> {
+    let id = get_property_id_from_nscsspropertyid!(property, Strong::null());
+    let mut declarations = SourcePropertyDeclaration::default();
+    let reporter = ErrorReporter::new(ptr::null_mut(), loader, data);
+    let data = UrlExtraData::from_ptr_ref(&data);
+    let result = parse_property_into(
+        &mut declarations,
+        id,
+        value,
+        Origin::Author,
+        data,
+        parsing_mode,
+        quirks_mode.into(),
+        rule_type,
+        reporter.as_ref().map(|r| r as &dyn ParseErrorReporter),
+    );
+
+    match result {
+        Ok(()) => {
+            let global_style_data = &*GLOBAL_STYLE_DATA;
+            let mut block = PropertyDeclarationBlock::new();
+            block.extend(declarations.drain(), Importance::Normal);
+            Arc::new(global_style_data.shared_lock.wrap(block)).into()
+        },
+        Err(_) => Strong::null(),
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ParseEasing(
+    easing: &nsACString,
+    output: &mut ComputedTimingFunction,
+) -> bool {
+    use style::properties::longhands::transition_timing_function;
+
+    let context = ParserContext::new(
+        Origin::Author,
+        unsafe { dummy_url_data() },
+        Some(CssRuleType::Style),
+        ParsingMode::DEFAULT,
+        QuirksMode::NoQuirks,
+        /* namespaces = */ Default::default(),
+        None,
+        None,
+    );
+    let easing = easing.to_string();
+    let mut input = ParserInput::new(&easing);
+    let mut parser = Parser::new(&mut input);
+    let result =
+        parser.parse_entirely(|p| transition_timing_function::single_value::parse(&context, p));
+    match result {
+        Ok(parsed_easing) => {
+            *output = parsed_easing.to_computed_value_without_context();
+            true
+        },
+        Err(_) => false,
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_SerializeEasing(easing: &ComputedTimingFunction, output: &mut nsACString) {
+    easing.to_css(&mut CssWriter::new(output)).unwrap();
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_GetProperties_Overriding_Animation(
+    element: &RawGeckoElement,
+    list: &nsTArray<nsCSSPropertyID>,
+    set: &mut structs::nsCSSPropertyIDSet,
+) {
+    let element = GeckoElement(element);
+    let element_data = match element.borrow_data() {
+        Some(data) => data,
+        None => return,
+    };
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    let guards = StylesheetGuards::same(&guard);
+    let (overridden, custom) = element_data
+        .styles
+        .primary()
+        .rules()
+        .get_properties_overriding_animations(&guards);
+    for p in list.iter() {
+        match PropertyId::from_nscsspropertyid(*p) {
+            Ok(property) => {
+                if let PropertyId::Longhand(id) = property {
+                    if overridden.contains(id) {
+                        unsafe { Gecko_AddPropertyToSet(set, *p) };
+                    }
+                }
+            },
+            Err(_) => {
+                if *p == nsCSSPropertyID::eCSSPropertyExtra_variable && custom {
+                    unsafe { Gecko_AddPropertyToSet(set, *p) };
+                }
+            },
+        }
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_MatrixTransform_Operate(
+    matrix_operator: MatrixTransformOperator,
+    from: *const structs::Matrix4x4Components,
+    to: *const structs::Matrix4x4Components,
+    progress: f64,
+    output: *mut structs::Matrix4x4Components,
+) {
+    use self::MatrixTransformOperator::{Accumulate, Interpolate};
+    use style::values::computed::transform::Matrix3D;
+
+    let from = Matrix3D::from(unsafe { from.as_ref() }.expect("not a valid 'from' matrix"));
+    let to = Matrix3D::from(unsafe { to.as_ref() }.expect("not a valid 'to' matrix"));
+    let result = match matrix_operator {
+        Interpolate => from.animate(&to, Procedure::Interpolate { progress }),
+        Accumulate => from.animate(
+            &to,
+            Procedure::Accumulate {
+                count: progress as u64,
+            },
+        ),
+    };
+
+    let output = unsafe { output.as_mut() }.expect("not a valid 'output' matrix");
+    if let Ok(result) = result {
+        *output = result.into();
+    } else if progress < 0.5 {
+        *output = from.clone().into();
+    } else {
+        *output = to.clone().into();
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_ParseStyleAttribute(
+    data: &nsACString,
+    raw_extra_data: *mut URLExtraData,
+    quirks_mode: nsCompatibility,
+    loader: *mut Loader,
+    rule_type: CssRuleType,
+) -> Strong<LockedDeclarationBlock> {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let value = data.as_str_unchecked();
+    let reporter = ErrorReporter::new(ptr::null_mut(), loader, raw_extra_data);
+    let url_data = UrlExtraData::from_ptr_ref(&raw_extra_data);
+    Arc::new(global_style_data.shared_lock.wrap(parse_style_attribute(
+        value,
+        url_data,
+        reporter.as_ref().map(|r| r as &dyn ParseErrorReporter),
+        quirks_mode.into(),
+        rule_type,
+    )))
+    .into()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_CreateEmpty() -> Strong<LockedDeclarationBlock> {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    Arc::new(
+        global_style_data
+            .shared_lock
+            .wrap(PropertyDeclarationBlock::new()),
+    )
+    .into()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_Clear(declarations: &LockedDeclarationBlock) {
+    write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
+        decls.clear();
+    });
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_Clone(
+    declarations: &LockedDeclarationBlock,
+) -> Strong<LockedDeclarationBlock> {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    Arc::new(
+        global_style_data
+            .shared_lock
+            .wrap(declarations.read_with(&guard).clone()),
+    )
+    .into()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_Equals(
+    a: &LockedDeclarationBlock,
+    b: &LockedDeclarationBlock,
+) -> bool {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    a.read_with(&guard).declarations() == b.read_with(&guard).declarations()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_GetCssText(
+    declarations: &LockedDeclarationBlock,
+    result: &mut nsACString,
+) {
+    read_locked_arc(declarations, |decls: &PropertyDeclarationBlock| {
+        decls.to_css(result).unwrap()
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_SerializeOneValue(
+    decls: &LockedDeclarationBlock,
+    property_id: nsCSSPropertyID,
+    buffer: &mut nsACString,
+    computed_values: Option<&ComputedValues>,
+    custom_properties: Option<&LockedDeclarationBlock>,
+    data: &PerDocumentStyleData,
+) {
+    let property_id = get_property_id_from_nscsspropertyid!(property_id, ());
+
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    let custom_properties = custom_properties.map(|block| block.read_with(&guard));
+    let data = data.borrow();
+    let rv = decls.read_with(&guard).single_value_to_css(
+        &property_id,
+        buffer,
+        computed_values,
+        custom_properties,
+        &data.stylist.device(),
+    );
+    debug_assert!(rv.is_ok());
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_SerializeFontValueForCanvas(
+    declarations: &LockedDeclarationBlock,
+    buffer: &mut nsACString,
+) {
+    use style::properties::shorthands::font;
+    read_locked_arc(declarations, |decls: &PropertyDeclarationBlock| {
+        let longhands = match font::LonghandsToSerialize::from_iter(decls.declarations().iter()) {
+            Ok(l) => l,
+            Err(()) => {
+                warn!("Unexpected property!");
+                return;
+            },
+        };
+
+        let rv = longhands.to_css(&mut CssWriter::new(buffer));
+        debug_assert!(rv.is_ok());
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_Count(declarations: &LockedDeclarationBlock) -> u32 {
+    read_locked_arc(declarations, |decls: &PropertyDeclarationBlock| {
+        decls.declarations().len() as u32
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_GetNthProperty(
+    declarations: &LockedDeclarationBlock,
+    index: u32,
+    result: &mut nsACString,
+) -> bool {
+    read_locked_arc(declarations, |decls: &PropertyDeclarationBlock| {
+        if let Some(decl) = decls.declarations().get(index as usize) {
+            result.assign(&decl.id().name());
+            true
+        } else {
+            false
+        }
+    })
+}
+
+macro_rules! get_property_id_from_property {
+    ($property: ident, $ret: expr) => {{
+        let property = $property.as_str_unchecked();
+        match PropertyId::parse_enabled_for_all_content(property) {
+            Ok(property_id) => property_id,
+            Err(_) => return $ret,
+        }
+    }};
+}
+
+unsafe fn get_property_value(
+    declarations: &LockedDeclarationBlock,
+    property_id: PropertyId,
+    value: &mut nsACString,
+) {
+    // This callsite is hot enough that the lock acquisition shows up in profiles.
+    // Using an unchecked read here improves our performance by ~10% on the
+    // microbenchmark in bug 1355599.
+    read_locked_arc_unchecked(declarations, |decls: &PropertyDeclarationBlock| {
+        decls.property_value_to_css(&property_id, value).unwrap();
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_DeclarationBlock_GetPropertyValue(
+    declarations: &LockedDeclarationBlock,
+    property: &nsACString,
+    value: &mut nsACString,
+) {
+    get_property_value(
+        declarations,
+        get_property_id_from_property!(property, ()),
+        value,
+    )
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_DeclarationBlock_GetPropertyValueById(
+    declarations: &LockedDeclarationBlock,
+    property: nsCSSPropertyID,
+    value: &mut nsACString,
+) {
+    get_property_value(
+        declarations,
+        get_property_id_from_nscsspropertyid!(property, ()),
+        value,
+    )
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_DeclarationBlock_GetPropertyIsImportant(
+    declarations: &LockedDeclarationBlock,
+    property: &nsACString,
+) -> bool {
+    let property_id = get_property_id_from_property!(property, false);
+    read_locked_arc(declarations, |decls: &PropertyDeclarationBlock| {
+        decls.property_priority(&property_id).important()
+    })
+}
+
+#[inline(always)]
+fn set_property_to_declarations(
+    non_custom_property_id: Option<NonCustomPropertyId>,
+    block: &LockedDeclarationBlock,
+    parsed_declarations: &mut SourcePropertyDeclaration,
+    before_change_closure: DeclarationBlockMutationClosure,
+    importance: Importance,
+) -> bool {
+    let mut updates = Default::default();
+    let will_change = read_locked_arc(block, |decls: &PropertyDeclarationBlock| {
+        decls.prepare_for_update(&parsed_declarations, importance, &mut updates)
+    });
+    if !will_change {
+        return false;
+    }
+
+    before_change_closure.invoke(non_custom_property_id);
+    write_locked_arc(block, |decls: &mut PropertyDeclarationBlock| {
+        decls.update(parsed_declarations.drain(), importance, &mut updates)
+    });
+    true
+}
+
+fn set_property(
+    declarations: &LockedDeclarationBlock,
+    property_id: PropertyId,
+    value: &nsACString,
+    is_important: bool,
+    data: &UrlExtraData,
+    parsing_mode: structs::ParsingMode,
+    quirks_mode: QuirksMode,
+    loader: *mut Loader,
+    rule_type: CssRuleType,
+    before_change_closure: DeclarationBlockMutationClosure,
+) -> bool {
+    let mut source_declarations = SourcePropertyDeclaration::default();
+    let reporter = ErrorReporter::new(ptr::null_mut(), loader, data.ptr());
+    let non_custom_property_id = property_id.non_custom_id();
+    let result = parse_property_into(
+        &mut source_declarations,
+        property_id,
+        value,
+        Origin::Author,
+        data,
+        parsing_mode,
+        quirks_mode,
+        rule_type,
+        reporter.as_ref().map(|r| r as &dyn ParseErrorReporter),
+    );
+
+    if result.is_err() {
+        return false;
+    }
+
+    let importance = if is_important {
+        Importance::Important
+    } else {
+        Importance::Normal
+    };
+
+    set_property_to_declarations(
+        non_custom_property_id,
+        declarations,
+        &mut source_declarations,
+        before_change_closure,
+        importance,
+    )
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_DeclarationBlock_SetProperty(
+    declarations: &LockedDeclarationBlock,
+    property: &nsACString,
+    value: &nsACString,
+    is_important: bool,
+    data: *mut URLExtraData,
+    parsing_mode: structs::ParsingMode,
+    quirks_mode: nsCompatibility,
+    loader: *mut Loader,
+    rule_type: CssRuleType,
+    before_change_closure: DeclarationBlockMutationClosure,
+) -> bool {
+    set_property(
+        declarations,
+        get_property_id_from_property!(property, false),
+        value,
+        is_important,
+        UrlExtraData::from_ptr_ref(&data),
+        parsing_mode,
+        quirks_mode.into(),
+        loader,
+        rule_type,
+        before_change_closure,
+    )
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_DeclarationBlock_SetPropertyToAnimationValue(
+    declarations: &LockedDeclarationBlock,
+    animation_value: &AnimationValue,
+    before_change_closure: DeclarationBlockMutationClosure,
+) -> bool {
+    let non_custom_property_id = animation_value.id().into();
+    let mut source_declarations = SourcePropertyDeclaration::with_one(animation_value.uncompute());
+
+    set_property_to_declarations(
+        Some(non_custom_property_id),
+        declarations,
+        &mut source_declarations,
+        before_change_closure,
+        Importance::Normal,
+    )
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_DeclarationBlock_SetPropertyById(
+    declarations: &LockedDeclarationBlock,
+    property: nsCSSPropertyID,
+    value: &nsACString,
+    is_important: bool,
+    data: *mut URLExtraData,
+    parsing_mode: structs::ParsingMode,
+    quirks_mode: nsCompatibility,
+    loader: *mut Loader,
+    rule_type: CssRuleType,
+    before_change_closure: DeclarationBlockMutationClosure,
+) -> bool {
+    set_property(
+        declarations,
+        get_property_id_from_nscsspropertyid!(property, false),
+        value,
+        is_important,
+        UrlExtraData::from_ptr_ref(&data),
+        parsing_mode,
+        quirks_mode.into(),
+        loader,
+        rule_type,
+        before_change_closure,
+    )
+}
+
+fn remove_property(
+    declarations: &LockedDeclarationBlock,
+    property_id: PropertyId,
+    before_change_closure: DeclarationBlockMutationClosure,
+) -> bool {
+    let first_declaration = read_locked_arc(declarations, |decls: &PropertyDeclarationBlock| {
+        decls.first_declaration_to_remove(&property_id)
+    });
+
+    let first_declaration = match first_declaration {
+        Some(i) => i,
+        None => return false,
+    };
+
+    before_change_closure.invoke(property_id.non_custom_id());
+    write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
+        decls.remove_property(&property_id, first_declaration)
+    });
+
+    true
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_DeclarationBlock_RemoveProperty(
+    declarations: &LockedDeclarationBlock,
+    property: &nsACString,
+    before_change_closure: DeclarationBlockMutationClosure,
+) -> bool {
+    remove_property(
+        declarations,
+        get_property_id_from_property!(property, false),
+        before_change_closure,
+    )
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_RemovePropertyById(
+    declarations: &LockedDeclarationBlock,
+    property: nsCSSPropertyID,
+    before_change_closure: DeclarationBlockMutationClosure,
+) -> bool {
+    remove_property(
+        declarations,
+        get_property_id_from_nscsspropertyid!(property, false),
+        before_change_closure,
+    )
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_MediaList_Create() -> Strong<LockedMediaList> {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    Arc::new(global_style_data.shared_lock.wrap(MediaList::empty())).into()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_MediaList_DeepClone(list: &LockedMediaList) -> Strong<LockedMediaList> {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    read_locked_arc(list, |list: &MediaList| {
+        Arc::new(global_style_data.shared_lock.wrap(list.clone())).into()
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_MediaList_Matches(
+    list: &LockedMediaList,
+    raw_data: &PerDocumentStyleData,
+) -> bool {
+    let per_doc_data = raw_data.borrow();
+    read_locked_arc(list, |list: &MediaList| {
+        list.evaluate(
+            per_doc_data.stylist.device(),
+            per_doc_data.stylist.quirks_mode(),
+        )
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_HasCSSWideKeyword(
+    declarations: &LockedDeclarationBlock,
+    property: nsCSSPropertyID,
+) -> bool {
+    let property_id = get_property_id_from_nscsspropertyid!(property, false);
+    read_locked_arc(declarations, |decls: &PropertyDeclarationBlock| {
+        decls.has_css_wide_keyword(&property_id)
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_MediaList_GetText(list: &LockedMediaList, result: &mut nsACString) {
+    read_locked_arc(list, |list: &MediaList| {
+        list.to_css(&mut CssWriter::new(result)).unwrap();
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_MediaList_SetText(
+    list: &LockedMediaList,
+    text: &nsACString,
+    caller_type: CallerType,
+) {
+    let text = text.as_str_unchecked();
+
+    let mut input = ParserInput::new(&text);
+    let mut parser = Parser::new(&mut input);
+    let url_data = dummy_url_data();
+
+    // TODO(emilio): If the need for `CallerType` appears in more places,
+    // consider adding an explicit member in `ParserContext` instead of doing
+    // this (or adding a dummy "chrome://" url data).
+    //
+    // For media query parsing it's effectively the same, so for now...
+    let origin = match caller_type {
+        CallerType::System => Origin::UserAgent,
+        CallerType::NonSystem => Origin::Author,
+    };
+
+    let context = ParserContext::new(
+        origin,
+        url_data,
+        Some(CssRuleType::Media),
+        ParsingMode::DEFAULT,
+        QuirksMode::NoQuirks,
+        /* namespaces = */ Default::default(),
+        // TODO(emilio): Looks like error reporting could be useful here?
+        None,
+        None,
+    );
+
+    write_locked_arc(list, |list: &mut MediaList| {
+        *list = MediaList::parse(&context, &mut parser);
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_MediaList_IsViewportDependent(list: &LockedMediaList) -> bool {
+    read_locked_arc(list, |list: &MediaList| list.is_viewport_dependent())
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_MediaList_GetLength(list: &LockedMediaList) -> u32 {
+    read_locked_arc(list, |list: &MediaList| list.media_queries.len() as u32)
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_MediaList_GetMediumAt(
+    list: &LockedMediaList,
+    index: u32,
+    result: &mut nsACString,
+) -> bool {
+    read_locked_arc(list, |list: &MediaList| {
+        let media_query = match list.media_queries.get(index as usize) {
+            Some(mq) => mq,
+            None => return false,
+        };
+        media_query.to_css(&mut CssWriter::new(result)).unwrap();
+        true
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_MediaList_AppendMedium(list: &LockedMediaList, new_medium: &nsACString) {
+    let new_medium = unsafe { new_medium.as_str_unchecked() };
+    let url_data = unsafe { dummy_url_data() };
+    let context = ParserContext::new(
+        Origin::Author,
+        url_data,
+        Some(CssRuleType::Media),
+        ParsingMode::DEFAULT,
+        QuirksMode::NoQuirks,
+        /* namespaces = */ Default::default(),
+        None,
+        None,
+    );
+    write_locked_arc(list, |list: &mut MediaList| {
+        list.append_medium(&context, new_medium);
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_MediaList_DeleteMedium(
+    list: &LockedMediaList,
+    old_medium: &nsACString,
+) -> bool {
+    let old_medium = unsafe { old_medium.as_str_unchecked() };
+    let url_data = unsafe { dummy_url_data() };
+    let context = ParserContext::new(
+        Origin::Author,
+        url_data,
+        Some(CssRuleType::Media),
+        ParsingMode::DEFAULT,
+        QuirksMode::NoQuirks,
+        /* namespaces = */ Default::default(),
+        None,
+        None,
+    );
+    write_locked_arc(list, |list: &mut MediaList| {
+        list.delete_medium(&context, old_medium)
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_MediaList_SizeOfIncludingThis(
+    malloc_size_of: GeckoMallocSizeOf,
+    malloc_enclosing_size_of: GeckoMallocSizeOf,
+    list: &LockedMediaList,
+) -> usize {
+    use malloc_size_of::MallocSizeOf;
+    use malloc_size_of::MallocUnconditionalShallowSizeOf;
+
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+
+    let mut ops = MallocSizeOfOps::new(
+        malloc_size_of.unwrap(),
+        Some(malloc_enclosing_size_of.unwrap()),
+        None,
+    );
+
+    unsafe { ArcBorrow::from_ref(list) }.with_arc(|list| {
+        let mut n = 0;
+        n += list.unconditional_shallow_size_of(&mut ops);
+        n += list.read_with(&guard).size_of(&mut ops);
+        n
+    })
+}
+
+macro_rules! get_longhand_from_id {
+    ($id:expr) => {
+        match PropertyId::from_nscsspropertyid($id) {
+            Ok(PropertyId::Longhand(long)) => long,
+            _ => panic!("stylo: unknown presentation property with id"),
+        }
+    };
+}
+
+macro_rules! match_wrap_declared {
+    ($longhand:ident, $($property:ident => $inner:expr,)*) => (
+        match $longhand {
+            $(
+                LonghandId::$property => PropertyDeclaration::$property($inner),
+            )*
+            _ => {
+                panic!("stylo: Don't know how to handle presentation property");
+            }
+        }
+    )
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_PropertyIsSet(
+    declarations: &LockedDeclarationBlock,
+    property: nsCSSPropertyID,
+) -> bool {
+    read_locked_arc(declarations, |decls: &PropertyDeclarationBlock| {
+        decls.contains(PropertyDeclarationId::Longhand(get_longhand_from_id!(
+            property
+        )))
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_DeclarationBlock_SetIdentStringValue(
+    declarations: &LockedDeclarationBlock,
+    property: nsCSSPropertyID,
+    value: *mut nsAtom,
+) {
+    use style::properties::longhands::_x_lang::computed_value::T as Lang;
+    use style::properties::PropertyDeclaration;
+
+    let long = get_longhand_from_id!(property);
+    let prop = match_wrap_declared! { long,
+        XLang => Lang(Atom::from_raw(value)),
+    };
+    write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
+        decls.push(prop, Importance::Normal);
+    })
+}
+
+#[no_mangle]
+#[allow(unreachable_code)]
+pub extern "C" fn Servo_DeclarationBlock_SetKeywordValue(
+    declarations: &LockedDeclarationBlock,
+    property: nsCSSPropertyID,
+    value: i32,
+) {
+    use num_traits::FromPrimitive;
+    use style::properties::longhands;
+    use style::properties::PropertyDeclaration;
+    use style::values::generics::box_::{VerticalAlign, VerticalAlignKeyword};
+    use style::values::generics::font::FontStyle;
+    use style::values::specified::{
+        table::CaptionSide, BorderStyle, Clear, Display, Float, TextAlign, TextEmphasisPosition,
+    };
+
+    fn get_from_computed<T>(value: u32) -> T
+    where
+        T: ToComputedValue,
+        T::ComputedValue: FromPrimitive,
+    {
+        T::from_computed_value(&T::ComputedValue::from_u32(value).unwrap())
+    }
+
+    let long = get_longhand_from_id!(property);
+    let value = value as u32;
+
+    let prop = match_wrap_declared! { long,
+        MozUserModify => longhands::_moz_user_modify::SpecifiedValue::from_gecko_keyword(value),
+        Direction => get_from_computed::<longhands::direction::SpecifiedValue>(value),
+        Display => get_from_computed::<Display>(value),
+        Float => get_from_computed::<Float>(value),
+        Clear => get_from_computed::<Clear>(value),
+        VerticalAlign => VerticalAlign::Keyword(VerticalAlignKeyword::from_u32(value).unwrap()),
+        TextAlign => get_from_computed::<TextAlign>(value),
+        TextEmphasisPosition => TextEmphasisPosition::from_bits_retain(value as u8),
+        FontSize => {
+            // We rely on Gecko passing in font-size values (0...7) here.
+            longhands::font_size::SpecifiedValue::from_html_size(value as u8)
+        },
+        FontStyle => {
+            style::values::specified::FontStyle::Specified(if value == structs::NS_FONT_STYLE_ITALIC {
+                FontStyle::Italic
+            } else {
+                debug_assert_eq!(value, structs::NS_FONT_STYLE_NORMAL);
+                FontStyle::Normal
+            })
+        },
+        FontWeight => longhands::font_weight::SpecifiedValue::from_gecko_keyword(value),
+        ListStyleType => Box::new(longhands::list_style_type::SpecifiedValue::from_gecko_keyword(value)),
+        MathStyle => longhands::math_style::SpecifiedValue::from_gecko_keyword(value),
+        MozMathVariant => longhands::_moz_math_variant::SpecifiedValue::from_gecko_keyword(value),
+        WhiteSpace => longhands::white_space::SpecifiedValue::from_gecko_keyword(value),
+        CaptionSide => get_from_computed::<CaptionSide>(value),
+        BorderTopStyle => get_from_computed::<BorderStyle>(value),
+        BorderRightStyle => get_from_computed::<BorderStyle>(value),
+        BorderBottomStyle => get_from_computed::<BorderStyle>(value),
+        BorderLeftStyle => get_from_computed::<BorderStyle>(value),
+    };
+    write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
+        decls.push(prop, Importance::Normal);
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_SetIntValue(
+    declarations: &LockedDeclarationBlock,
+    property: nsCSSPropertyID,
+    value: i32,
+) {
+    use style::properties::PropertyDeclaration;
+    use style::values::specified::Integer;
+
+    let long = get_longhand_from_id!(property);
+    let prop = match_wrap_declared! { long,
+        XSpan => Integer::new(value),
+    };
+    write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
+        decls.push(prop, Importance::Normal);
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_SetMathDepthValue(
+    declarations: &LockedDeclarationBlock,
+    value: i32,
+    is_relative: bool,
+) {
+    use style::properties::longhands::math_depth::SpecifiedValue as MathDepth;
+    use style::properties::PropertyDeclaration;
+
+    let integer_value = style::values::specified::Integer::new(value);
+    let prop = PropertyDeclaration::MathDepth(if is_relative {
+        MathDepth::Add(integer_value)
+    } else {
+        MathDepth::Absolute(integer_value)
+    });
+    write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
+        decls.push(prop, Importance::Normal);
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_SetCounterResetListItem(
+    declarations: &LockedDeclarationBlock,
+    counter_value: i32,
+    is_reversed: bool,
+) {
+    use style::properties::PropertyDeclaration;
+    use style::values::generics::counters::{CounterPair, CounterReset};
+
+    let prop = PropertyDeclaration::CounterReset(CounterReset::new(vec![CounterPair {
+        name: CustomIdent(atom!("list-item")),
+        value: style::values::specified::Integer::new(counter_value),
+        is_reversed,
+    }]));
+    write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
+        decls.push(prop, Importance::Normal);
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_SetCounterSetListItem(
+    declarations: &LockedDeclarationBlock,
+    counter_value: i32,
+) {
+    use style::properties::PropertyDeclaration;
+    use style::values::generics::counters::{CounterPair, CounterSet};
+
+    let prop = PropertyDeclaration::CounterSet(CounterSet::new(vec![CounterPair {
+        name: CustomIdent(atom!("list-item")),
+        value: style::values::specified::Integer::new(counter_value),
+        is_reversed: false,
+    }]));
+    write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
+        decls.push(prop, Importance::Normal);
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_SetPixelValue(
+    declarations: &LockedDeclarationBlock,
+    property: nsCSSPropertyID,
+    value: f32,
+) {
+    use style::properties::longhands::border_spacing::SpecifiedValue as BorderSpacing;
+    use style::properties::PropertyDeclaration;
+    use style::values::generics::length::{LengthPercentageOrAuto, Size};
+    use style::values::generics::NonNegative;
+    use style::values::specified::length::{
+        LengthPercentage, NonNegativeLength, NonNegativeLengthPercentage,
+    };
+    use style::values::specified::{BorderCornerRadius, BorderSideWidth};
+
+    let long = get_longhand_from_id!(property);
+    let nocalc = NoCalcLength::from_px(value);
+    let lp = LengthPercentage::Length(nocalc);
+    let lp_or_auto = LengthPercentageOrAuto::LengthPercentage(lp.clone());
+    let prop = match_wrap_declared! { long,
+        Height => Size::LengthPercentage(NonNegative(lp)),
+        Width => Size::LengthPercentage(NonNegative(lp)),
+        BorderTopWidth => BorderSideWidth::from_px(value),
+        BorderRightWidth => BorderSideWidth::from_px(value),
+        BorderBottomWidth => BorderSideWidth::from_px(value),
+        BorderLeftWidth => BorderSideWidth::from_px(value),
+        MarginTop => lp_or_auto,
+        MarginRight => lp_or_auto,
+        MarginBottom => lp_or_auto,
+        MarginLeft => lp_or_auto,
+        PaddingTop => NonNegative(lp),
+        PaddingRight => NonNegative(lp),
+        PaddingBottom => NonNegative(lp),
+        PaddingLeft => NonNegative(lp),
+        BorderSpacing => {
+            let v = NonNegativeLength::from(nocalc);
+            Box::new(BorderSpacing::new(v.clone(), v))
+        },
+        BorderTopLeftRadius => {
+            let length = NonNegativeLengthPercentage::from(nocalc);
+            Box::new(BorderCornerRadius::new(length.clone(), length))
+        },
+        BorderTopRightRadius => {
+            let length = NonNegativeLengthPercentage::from(nocalc);
+            Box::new(BorderCornerRadius::new(length.clone(), length))
+        },
+        BorderBottomLeftRadius => {
+            let length = NonNegativeLengthPercentage::from(nocalc);
+            Box::new(BorderCornerRadius::new(length.clone(), length))
+        },
+        BorderBottomRightRadius => {
+            let length = NonNegativeLengthPercentage::from(nocalc);
+            Box::new(BorderCornerRadius::new(length.clone(), length))
+        },
+    };
+    write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
+        decls.push(prop, Importance::Normal);
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_SetLengthValue(
+    declarations: &LockedDeclarationBlock,
+    property: nsCSSPropertyID,
+    value: f32,
+    unit: structs::nsCSSUnit,
+) {
+    use style::properties::longhands::_moz_script_min_size::SpecifiedValue as MozScriptMinSize;
+    use style::properties::PropertyDeclaration;
+    use style::values::generics::length::{LengthPercentageOrAuto, Size};
+    use style::values::generics::NonNegative;
+    use style::values::specified::length::{FontRelativeLength, LengthPercentage};
+    use style::values::specified::FontSize;
+
+    let long = get_longhand_from_id!(property);
+    let nocalc = match unit {
+        structs::nsCSSUnit::eCSSUnit_EM => {
+            NoCalcLength::FontRelative(FontRelativeLength::Em(value))
+        },
+        structs::nsCSSUnit::eCSSUnit_XHeight => {
+            NoCalcLength::FontRelative(FontRelativeLength::Ex(value))
+        },
+        structs::nsCSSUnit::eCSSUnit_Pixel => NoCalcLength::Absolute(AbsoluteLength::Px(value)),
+        structs::nsCSSUnit::eCSSUnit_Inch => NoCalcLength::Absolute(AbsoluteLength::In(value)),
+        structs::nsCSSUnit::eCSSUnit_Centimeter => {
+            NoCalcLength::Absolute(AbsoluteLength::Cm(value))
+        },
+        structs::nsCSSUnit::eCSSUnit_Millimeter => {
+            NoCalcLength::Absolute(AbsoluteLength::Mm(value))
+        },
+        structs::nsCSSUnit::eCSSUnit_Point => NoCalcLength::Absolute(AbsoluteLength::Pt(value)),
+        structs::nsCSSUnit::eCSSUnit_Pica => NoCalcLength::Absolute(AbsoluteLength::Pc(value)),
+        structs::nsCSSUnit::eCSSUnit_Quarter => NoCalcLength::Absolute(AbsoluteLength::Q(value)),
+        _ => unreachable!("Unknown unit passed to SetLengthValue"),
+    };
+
+    let prop = match_wrap_declared! { long,
+        Width => Size::LengthPercentage(NonNegative(LengthPercentage::Length(nocalc))),
+        Height => Size::LengthPercentage(NonNegative(LengthPercentage::Length(nocalc))),
+        X =>  LengthPercentage::Length(nocalc),
+        Y =>  LengthPercentage::Length(nocalc),
+        Cx => LengthPercentage::Length(nocalc),
+        Cy => LengthPercentage::Length(nocalc),
+        R =>  NonNegative(LengthPercentage::Length(nocalc)),
+        Rx => LengthPercentageOrAuto::LengthPercentage(NonNegative(LengthPercentage::Length(nocalc))),
+        Ry => LengthPercentageOrAuto::LengthPercentage(NonNegative(LengthPercentage::Length(nocalc))),
+        FontSize => FontSize::Length(LengthPercentage::Length(nocalc)),
+        MozScriptMinSize => MozScriptMinSize(nocalc),
+    };
+    write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
+        decls.push(prop, Importance::Normal);
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_SetPathValue(
+    declarations: &LockedDeclarationBlock,
+    property: nsCSSPropertyID,
+    path: &nsTArray<f32>,
+) {
+    use style::properties::PropertyDeclaration;
+    use style::values::specified::DProperty;
+
+    // 1. Decode the path data from SVG.
+    let path = match specified::SVGPathData::decode_from_f32_array(path) {
+        Ok(p) => p,
+        Err(()) => return,
+    };
+
+    // 2. Set decoded path into style.
+    let long = get_longhand_from_id!(property);
+    let prop = match_wrap_declared! { long,
+        D => if path.0.is_empty() { DProperty::None } else { DProperty::Path(path) },
+    };
+    write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
+        decls.push(prop, Importance::Normal);
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_SetNumberValue(
+    declarations: &LockedDeclarationBlock,
+    property: nsCSSPropertyID,
+    value: f32,
+) {
+    use style::properties::longhands::_moz_script_size_multiplier::SpecifiedValue as MozScriptSizeMultiplier;
+    use style::properties::PropertyDeclaration;
+
+    let long = get_longhand_from_id!(property);
+
+    let prop = match_wrap_declared! { long,
+        MozScriptSizeMultiplier => MozScriptSizeMultiplier(value),
+    };
+    write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
+        decls.push(prop, Importance::Normal);
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_SetPercentValue(
+    declarations: &LockedDeclarationBlock,
+    property: nsCSSPropertyID,
+    value: f32,
+) {
+    use style::properties::PropertyDeclaration;
+    use style::values::computed::Percentage;
+    use style::values::generics::length::{LengthPercentageOrAuto, Size};
+    use style::values::generics::NonNegative;
+    use style::values::specified::length::LengthPercentage;
+    use style::values::specified::FontSize;
+
+    let long = get_longhand_from_id!(property);
+    let pc = Percentage(value);
+    let lp = LengthPercentage::Percentage(pc);
+    let lp_or_auto = LengthPercentageOrAuto::LengthPercentage(lp.clone());
+
+    let prop = match_wrap_declared! { long,
+        Height => Size::LengthPercentage(NonNegative(lp)),
+        Width => Size::LengthPercentage(NonNegative(lp)),
+        X =>  lp,
+        Y =>  lp,
+        Cx => lp,
+        Cy => lp,
+        R =>  NonNegative(lp),
+        Rx => LengthPercentageOrAuto::LengthPercentage(NonNegative(lp)),
+        Ry => LengthPercentageOrAuto::LengthPercentage(NonNegative(lp)),
+        MarginTop => lp_or_auto,
+        MarginRight => lp_or_auto,
+        MarginBottom => lp_or_auto,
+        MarginLeft => lp_or_auto,
+        FontSize => FontSize::Length(LengthPercentage::Percentage(pc)),
+    };
+    write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
+        decls.push(prop, Importance::Normal);
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_SetAutoValue(
+    declarations: &LockedDeclarationBlock,
+    property: nsCSSPropertyID,
+) {
+    use style::properties::PropertyDeclaration;
+    use style::values::generics::length::{LengthPercentageOrAuto, Size};
+
+    let long = get_longhand_from_id!(property);
+    let auto = LengthPercentageOrAuto::Auto;
+
+    let prop = match_wrap_declared! { long,
+        Height => Size::auto(),
+        Width => Size::auto(),
+        MarginTop => auto,
+        MarginRight => auto,
+        MarginBottom => auto,
+        MarginLeft => auto,
+        AspectRatio => specified::AspectRatio::auto(),
+    };
+    write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
+        decls.push(prop, Importance::Normal);
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_SetCurrentColor(
+    declarations: &LockedDeclarationBlock,
+    property: nsCSSPropertyID,
+) {
+    use style::properties::PropertyDeclaration;
+    use style::values::specified::Color;
+
+    let long = get_longhand_from_id!(property);
+    let cc = Color::currentcolor();
+
+    let prop = match_wrap_declared! { long,
+        BorderTopColor => cc,
+        BorderRightColor => cc,
+        BorderBottomColor => cc,
+        BorderLeftColor => cc,
+    };
+    write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
+        decls.push(prop, Importance::Normal);
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_SetColorValue(
+    declarations: &LockedDeclarationBlock,
+    property: nsCSSPropertyID,
+    value: structs::nscolor,
+) {
+    use style::gecko::values::convert_nscolor_to_absolute_color;
+    use style::properties::longhands;
+    use style::properties::PropertyDeclaration;
+    use style::values::specified::Color;
+
+    let long = get_longhand_from_id!(property);
+    let rgba = convert_nscolor_to_absolute_color(value);
+    let color = Color::from_absolute_color(rgba);
+
+    let prop = match_wrap_declared! { long,
+        BorderTopColor => color,
+        BorderRightColor => color,
+        BorderBottomColor => color,
+        BorderLeftColor => color,
+        Color => longhands::color::SpecifiedValue(color),
+        BackgroundColor => color,
+    };
+    write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
+        decls.push(prop, Importance::Normal);
+    })
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_DeclarationBlock_SetFontFamily(
+    declarations: &LockedDeclarationBlock,
+    value: &nsACString,
+) {
+    use style::properties::longhands::font_family::SpecifiedValue as FontFamily;
+    use style::properties::PropertyDeclaration;
+
+    let string = value.as_str_unchecked();
+    let mut input = ParserInput::new(&string);
+    let mut parser = Parser::new(&mut input);
+    let context = ParserContext::new(
+        Origin::Author,
+        dummy_url_data(),
+        Some(CssRuleType::Style),
+        ParsingMode::DEFAULT,
+        QuirksMode::NoQuirks,
+        /* namespaces = */ Default::default(),
+        None,
+        None,
+    );
+    let result = FontFamily::parse(&context, &mut parser);
+    if let Ok(family) = result {
+        if parser.is_exhausted() {
+            let decl = PropertyDeclaration::FontFamily(family);
+            write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
+                decls.push(decl, Importance::Normal);
+            })
+        }
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_DeclarationBlock_SetBackgroundImage(
+    declarations: &LockedDeclarationBlock,
+    value: &nsACString,
+    raw_extra_data: *mut URLExtraData,
+) {
+    use style::properties::longhands::background_image::SpecifiedValue as BackgroundImage;
+    use style::properties::PropertyDeclaration;
+    use style::stylesheets::CorsMode;
+    use style::values::generics::image::Image;
+    use style::values::specified::url::SpecifiedImageUrl;
+
+    let url_data = UrlExtraData::from_ptr_ref(&raw_extra_data);
+    let string = value.as_str_unchecked();
+    let context = ParserContext::new(
+        Origin::Author,
+        url_data,
+        Some(CssRuleType::Style),
+        ParsingMode::DEFAULT,
+        QuirksMode::NoQuirks,
+        /* namespaces = */ Default::default(),
+        None,
+        None,
+    );
+    let url = SpecifiedImageUrl::parse_from_string(string.into(), &context, CorsMode::None);
+    let decl = PropertyDeclaration::BackgroundImage(BackgroundImage(vec![Image::Url(url)].into()));
+    write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
+        decls.push(decl, Importance::Normal);
+    });
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_SetTextDecorationColorOverride(
+    declarations: &LockedDeclarationBlock,
+) {
+    use style::properties::PropertyDeclaration;
+    use style::values::specified::text::TextDecorationLine;
+
+    let decoration = TextDecorationLine::COLOR_OVERRIDE;
+    let decl = PropertyDeclaration::TextDecorationLine(decoration);
+    write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
+        decls.push(decl, Importance::Normal);
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_DeclarationBlock_SetAspectRatio(
+    declarations: &LockedDeclarationBlock,
+    width: f32,
+    height: f32,
+) {
+    use style::properties::PropertyDeclaration;
+    use style::values::generics::position::AspectRatio;
+
+    let decl = PropertyDeclaration::AspectRatio(AspectRatio::from_mapped_ratio(width, height));
+    write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
+        decls.push(decl, Importance::Normal);
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_CSSSupports2(property: &nsACString, value: &nsACString) -> bool {
+    let id = unsafe { get_property_id_from_property!(property, false) };
+
+    let mut declarations = SourcePropertyDeclaration::default();
+    parse_property_into(
+        &mut declarations,
+        id,
+        value,
+        Origin::Author,
+        unsafe { dummy_url_data() },
+        structs::ParsingMode_Default,
+        QuirksMode::NoQuirks,
+        CssRuleType::Style,
+        None,
+    )
+    .is_ok()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_CSSSupports(
+    cond: &nsACString,
+    ua_origin: bool,
+    chrome_sheet: bool,
+    quirks: bool,
+) -> bool {
+    let condition = unsafe { cond.as_str_unchecked() };
+    let mut input = ParserInput::new(&condition);
+    let mut input = Parser::new(&mut input);
+    let cond = match input.parse_entirely(parse_condition_or_declaration) {
+        Ok(c) => c,
+        Err(..) => return false,
+    };
+
+    let origin = if ua_origin {
+        Origin::UserAgent
+    } else {
+        Origin::Author
+    };
+    let url_data = unsafe {
+        UrlExtraData::from_ptr_ref(if chrome_sheet {
+            &DUMMY_CHROME_URL_DATA
+        } else {
+            &DUMMY_URL_DATA
+        })
+    };
+    let quirks_mode = if quirks {
+        QuirksMode::Quirks
+    } else {
+        QuirksMode::NoQuirks
+    };
+
+    // NOTE(emilio): The supports API is not associated to any stylesheet,
+    // so the fact that there is no namespace map here is fine.
+    let context = ParserContext::new(
+        origin,
+        url_data,
+        Some(CssRuleType::Style),
+        ParsingMode::DEFAULT,
+        quirks_mode,
+        /* namespaces = */ Default::default(),
+        None,
+        None,
+    );
+
+    cond.eval(&context)
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_CSSSupportsForImport(after_rule: &nsACString) -> bool {
+    let condition = unsafe { after_rule.as_str_unchecked() };
+    let mut input = ParserInput::new(&condition);
+    let mut input = Parser::new(&mut input);
+
+    // NOTE(emilio): The supports API is not associated to any stylesheet,
+    // so the fact that there is no namespace map here is fine.
+    let mut context = ParserContext::new(
+        Origin::Author,
+        unsafe { dummy_url_data() },
+        Some(CssRuleType::Style),
+        ParsingMode::DEFAULT,
+        QuirksMode::NoQuirks,
+        /* namespaces = */ Default::default(),
+        None,
+        None,
+    );
+
+    let (_layer, supports) = ImportRule::parse_layer_and_supports(&mut input, &mut context);
+
+    supports.map_or(true, |s| s.enabled)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_NoteExplicitHints(
+    element: &RawGeckoElement,
+    restyle_hint: RestyleHint,
+    change_hint: nsChangeHint,
+) {
+    GeckoElement(element).note_explicit_hints(restyle_hint, change_hint);
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_TakeChangeHint(element: &RawGeckoElement, was_restyled: *mut bool) -> u32 {
+    let was_restyled = unsafe { was_restyled.as_mut().unwrap() };
+    let element = GeckoElement(element);
+
+    let damage = match element.mutate_data() {
+        Some(mut data) => {
+            *was_restyled = data.is_restyle();
+
+            let damage = data.damage;
+            data.clear_restyle_state();
+            damage
+        },
+        None => {
+            warn!("Trying to get change hint from unstyled element");
+            *was_restyled = false;
+            GeckoRestyleDamage::empty()
+        },
+    };
+
+    debug!("Servo_TakeChangeHint: {:?}, damage={:?}", element, damage);
+    // We'd like to return `nsChangeHint` here, but bindgen bitfield enums don't
+    // work as return values with the Linux 32-bit ABI at the moment because
+    // they wrap the value in a struct, so for now just unwrap it.
+    damage.as_change_hint().0
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ResolveStyle(element: &RawGeckoElement) -> Strong<ComputedValues> {
+    let element = GeckoElement(element);
+    debug!("Servo_ResolveStyle: {:?}", element);
+    let data = element
+        .borrow_data()
+        .expect("Resolving style on unstyled element");
+
+    debug_assert!(
+        element.has_current_styles(&*data),
+        "Resolving style on {:?} without current styles: {:?}",
+        element,
+        data
+    );
+    data.styles.primary().clone().into()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ResolveStyleLazily(
+    element: &RawGeckoElement,
+    pseudo_type: PseudoStyleType,
+    rule_inclusion: StyleRuleInclusion,
+    snapshots: *const ServoElementSnapshotTable,
+    cache_generation: u64,
+    can_use_cache: bool,
+    raw_data: &PerDocumentStyleData,
+) -> Strong<ComputedValues> {
+    use selectors::Element;
+    debug_assert!(!snapshots.is_null());
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    let element = GeckoElement(element);
+    let mut data = raw_data.borrow_mut();
+    let mut data = &mut *data;
+    let rule_inclusion = RuleInclusion::from(rule_inclusion);
+    let pseudo = PseudoElement::from_pseudo_type(pseudo_type);
+
+    if cache_generation != data.undisplayed_style_cache_generation {
+        data.undisplayed_style_cache.clear();
+        data.undisplayed_style_cache_generation = cache_generation;
+    }
+
+    let stylist = &data.stylist;
+    let finish = |styles: &ElementStyles, is_probe: bool| -> Option<Arc<ComputedValues>> {
+        match pseudo {
+            Some(ref pseudo) => {
+                get_pseudo_style(
+                    &guard,
+                    element,
+                    pseudo,
+                    rule_inclusion,
+                    styles,
+                    /* inherited_styles = */ None,
+                    &stylist,
+                    is_probe,
+                    /* matching_func = */ None,
+                )
+            },
+            None => Some(styles.primary().clone()),
+        }
+    };
+
+    let is_before_or_after = pseudo.as_ref().map_or(false, |p| p.is_before_or_after());
+
+    // In the common case we already have the style. Check that before setting
+    // up all the computation machinery.
+    //
+    // Also, only probe in the ::before or ::after case, since their styles may
+    // not be in the `ElementData`, given they may exist but not be applicable
+    // to generate an actual pseudo-element (like, having a `content: none`).
+    if rule_inclusion == RuleInclusion::All {
+        let styles = element.borrow_data().and_then(|d| {
+            if d.has_styles() {
+                finish(&d.styles, is_before_or_after)
+            } else {
+                None
+            }
+        });
+        if let Some(result) = styles {
+            return result.into();
+        }
+        if pseudo.is_none() && can_use_cache {
+            if let Some(style) = data.undisplayed_style_cache.get(&element.opaque()) {
+                return style.clone().into();
+            }
+        }
+    }
+
+    // We don't have the style ready. Go ahead and compute it as necessary.
+    let shared = create_shared_context(
+        &global_style_data,
+        &guard,
+        &stylist,
+        TraversalFlags::empty(),
+        unsafe { &*snapshots },
+    );
+    let mut tlc = ThreadLocalStyleContext::new();
+    let mut context = StyleContext {
+        shared: &shared,
+        thread_local: &mut tlc,
+    };
+
+    let styles = resolve_style(
+        &mut context,
+        element,
+        rule_inclusion,
+        pseudo.as_ref(),
+        if can_use_cache {
+            Some(&mut data.undisplayed_style_cache)
+        } else {
+            None
+        },
+    );
+
+    finish(&styles, /* is_probe = */ false)
+        .expect("We're not probing, so we should always get a style back")
+        .into()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ReparentStyle(
+    style_to_reparent: &ComputedValues,
+    parent_style: &ComputedValues,
+    parent_style_ignoring_first_line: &ComputedValues,
+    layout_parent_style: &ComputedValues,
+    element: Option<&RawGeckoElement>,
+    raw_data: &PerDocumentStyleData,
+) -> Strong<ComputedValues> {
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    let doc_data = raw_data.borrow();
+    let inputs = CascadeInputs::new_from_style(style_to_reparent);
+    let pseudo = style_to_reparent.pseudo();
+    let element = element.map(GeckoElement);
+
+    doc_data
+        .stylist
+        .cascade_style_and_visited(
+            element,
+            pseudo.as_ref(),
+            inputs,
+            &StylesheetGuards::same(&guard),
+            match element.is_some() && pseudo.is_some() {
+                true => Some(parent_style),
+                false => None,
+            },
+            Some(parent_style),
+            Some(parent_style_ignoring_first_line),
+            Some(layout_parent_style),
+            /* rule_cache = */ None,
+            &mut RuleCacheConditions::default(),
+        )
+        .into()
+}
+
+#[cfg(feature = "gecko_debug")]
+fn simulate_compute_values_failure(property: &PropertyValuePair) -> bool {
+    let p = property.mProperty;
+    let id = get_property_id_from_nscsspropertyid!(p, false);
+    id.as_shorthand().is_ok() && property.mSimulateComputeValuesFailure
+}
+
+#[cfg(not(feature = "gecko_debug"))]
+fn simulate_compute_values_failure(_: &PropertyValuePair) -> bool {
+    false
+}
+
+fn create_context_for_animation<'a>(
+    per_doc_data: &'a PerDocumentStyleDataImpl,
+    style: &'a ComputedValues,
+    parent_style: Option<&'a ComputedValues>,
+    for_smil_animation: bool,
+    rule_cache_conditions: &'a mut RuleCacheConditions,
+    container_size_query: ContainerSizeQuery<'a>,
+) -> Context<'a> {
+    Context::new_for_animation(
+        StyleBuilder::for_animation(per_doc_data.stylist.device(), style, parent_style),
+        for_smil_animation,
+        per_doc_data.stylist.quirks_mode(),
+        rule_cache_conditions,
+        container_size_query,
+    )
+}
+
+struct PropertyAndIndex {
+    property: PropertyId,
+    index: usize,
+}
+
+struct PrioritizedPropertyIter<'a> {
+    properties: &'a [PropertyValuePair],
+    sorted_property_indices: Vec<PropertyAndIndex>,
+    curr: usize,
+}
+
+impl<'a> PrioritizedPropertyIter<'a> {
+    fn new(properties: &'a [PropertyValuePair]) -> PrioritizedPropertyIter {
+        use style::values::animated::compare_property_priority;
+
+        // If we fail to convert a nsCSSPropertyID into a PropertyId we
+        // shouldn't fail outright but instead by treating that property as the
+        // 'all' property we make it sort last.
+        let mut sorted_property_indices: Vec<PropertyAndIndex> = properties
+            .iter()
+            .enumerate()
+            .map(|(index, pair)| {
+                let property = PropertyId::from_nscsspropertyid(pair.mProperty)
+                    .unwrap_or(PropertyId::Shorthand(ShorthandId::All));
+
+                PropertyAndIndex { property, index }
+            })
+            .collect();
+        sorted_property_indices.sort_by(|a, b| compare_property_priority(&a.property, &b.property));
+
+        PrioritizedPropertyIter {
+            properties,
+            sorted_property_indices,
+            curr: 0,
+        }
+    }
+}
+
+impl<'a> Iterator for PrioritizedPropertyIter<'a> {
+    type Item = &'a PropertyValuePair;
+
+    fn next(&mut self) -> Option<&'a PropertyValuePair> {
+        if self.curr >= self.sorted_property_indices.len() {
+            return None;
+        }
+        self.curr += 1;
+        Some(&self.properties[self.sorted_property_indices[self.curr - 1].index])
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_GetComputedKeyframeValues(
+    keyframes: &nsTArray<structs::Keyframe>,
+    element: &RawGeckoElement,
+    pseudo_type: PseudoStyleType,
+    style: &ComputedValues,
+    raw_data: &PerDocumentStyleData,
+    computed_keyframes: &mut nsTArray<structs::ComputedKeyframeValues>,
+) {
+    let data = raw_data.borrow();
+    let element = GeckoElement(element);
+    let pseudo = PseudoElement::from_pseudo_type(pseudo_type);
+    let parent_element = if pseudo.is_none() {
+        element.inheritance_parent()
+    } else {
+        Some(element)
+    };
+    let parent_data = parent_element.as_ref().and_then(|e| e.borrow_data());
+    let parent_style = parent_data
+        .as_ref()
+        .map(|d| d.styles.primary())
+        .map(|x| &**x);
+
+    let container_size_query =
+        ContainerSizeQuery::for_element(element, pseudo.as_ref().and(parent_style));
+    let mut conditions = Default::default();
+    let mut context = create_context_for_animation(
+        &data,
+        &style,
+        parent_style,
+        /* for_smil_animation = */ false,
+        &mut conditions,
+        container_size_query,
+    );
+
+    let restriction = pseudo.and_then(|p| p.property_restriction());
+
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    let default_values = data.default_computed_values();
+
+    let mut raw_custom_properties_block; // To make the raw block alive in the scope.
+    for (index, keyframe) in keyframes.iter().enumerate() {
+        let mut custom_properties = None;
+        for property in keyframe.mPropertyValues.iter() {
+            // Find the block for custom properties first.
+            if property.mProperty == nsCSSPropertyID::eCSSPropertyExtra_variable {
+                raw_custom_properties_block = unsafe { &*property.mServoDeclarationBlock.mRawPtr };
+                let guard = raw_custom_properties_block.read_with(&guard);
+                custom_properties = guard.cascade_custom_properties_with_context(&context);
+                // There should be one PropertyDeclarationBlock for custom properties.
+                break;
+            }
+        }
+
+        let ref mut animation_values = computed_keyframes[index];
+
+        let mut seen = LonghandIdSet::new();
+
+        let mut property_index = 0;
+        for property in PrioritizedPropertyIter::new(&keyframe.mPropertyValues) {
+            if simulate_compute_values_failure(property) {
+                continue;
+            }
+
+            let mut maybe_append_animation_value =
+                |property: LonghandId, value: Option<AnimationValue>| {
+                    debug_assert!(!property.is_logical());
+                    debug_assert!(property.is_animatable());
+
+                    // 'display' is only animatable from SMIL
+                    if property == LonghandId::Display {
+                        return;
+                    }
+
+                    // Skip restricted properties
+                    if restriction.map_or(false, |r| !property.flags().contains(r)) {
+                        return;
+                    }
+
+                    if seen.contains(property) {
+                        return;
+                    }
+                    seen.insert(property);
+
+                    // This is safe since we immediately write to the uninitialized values.
+                    unsafe {
+                        animation_values.set_len((property_index + 1) as u32);
+                        ptr::write(
+                            &mut animation_values[property_index],
+                            structs::PropertyStyleAnimationValuePair {
+                                mProperty: property.to_nscsspropertyid(),
+                                mValue: structs::AnimationValue {
+                                    mServo: value.map_or(structs::RefPtr::null(), |v| {
+                                        structs::RefPtr::from_arc(Arc::new(v))
+                                    }),
+                                },
+                            },
+                        );
+                    }
+                    property_index += 1;
+                };
+
+            if property.mServoDeclarationBlock.mRawPtr.is_null() {
+                let property = LonghandId::from_nscsspropertyid(property.mProperty);
+                if let Ok(prop) = property {
+                    maybe_append_animation_value(prop, None);
+                }
+                continue;
+            }
+
+            let declarations = unsafe { &*property.mServoDeclarationBlock.mRawPtr };
+            let guard = declarations.read_with(&guard);
+            let iter = guard.to_animation_value_iter(
+                &mut context,
+                &default_values,
+                custom_properties.as_ref(),
+            );
+
+            for value in iter {
+                let id = value.id();
+                maybe_append_animation_value(id, Some(value));
+            }
+        }
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_GetAnimationValues(
+    declarations: &LockedDeclarationBlock,
+    element: &RawGeckoElement,
+    style: &ComputedValues,
+    raw_data: &PerDocumentStyleData,
+    animation_values: &mut ThinVec<structs::RefPtr<AnimationValue>>,
+) {
+    let data = raw_data.borrow();
+    let element = GeckoElement(element);
+    let parent_element = element.inheritance_parent();
+    let parent_data = parent_element.as_ref().and_then(|e| e.borrow_data());
+    let parent_style = parent_data
+        .as_ref()
+        .map(|d| d.styles.primary())
+        .map(|x| &**x);
+
+    let container_size_query = ContainerSizeQuery::for_element(element, None);
+    let mut conditions = Default::default();
+    let mut context = create_context_for_animation(
+        &data,
+        &style,
+        parent_style,
+        /* for_smil_animation = */ true,
+        &mut conditions,
+        container_size_query,
+    );
+
+    let default_values = data.default_computed_values();
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+
+    let guard = declarations.read_with(&guard);
+    let iter = guard.to_animation_value_iter(
+        &mut context,
+        &default_values,
+        None, // SMIL has no extra custom properties.
+    );
+    animation_values.extend(iter.map(|v| structs::RefPtr::from_arc(Arc::new(v))));
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AnimationValue_GetPropertyId(value: &AnimationValue) -> nsCSSPropertyID {
+    value.id().to_nscsspropertyid()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AnimationValue_Compute(
+    element: &RawGeckoElement,
+    declarations: &LockedDeclarationBlock,
+    style: &ComputedValues,
+    raw_data: &PerDocumentStyleData,
+) -> Strong<AnimationValue> {
+    let data = raw_data.borrow();
+
+    let element = GeckoElement(element);
+    let parent_element = element.inheritance_parent();
+    let parent_data = parent_element.as_ref().and_then(|e| e.borrow_data());
+    let parent_style = parent_data
+        .as_ref()
+        .map(|d| d.styles.primary())
+        .map(|x| &**x);
+
+    let container_size_query = ContainerSizeQuery::for_element(element, None);
+    let mut conditions = Default::default();
+    let mut context = create_context_for_animation(
+        &data,
+        style,
+        parent_style,
+        /* for_smil_animation = */ false,
+        &mut conditions,
+        container_size_query,
+    );
+
+    let default_values = data.default_computed_values();
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    // We only compute the first element in declarations.
+    match declarations
+        .read_with(&guard)
+        .declaration_importance_iter()
+        .next()
+    {
+        Some((decl, imp)) if imp == Importance::Normal => {
+            let animation = AnimationValue::from_declaration(
+                decl,
+                &mut context,
+                None, // No extra custom properties for devtools.
+                default_values,
+            );
+            animation.map_or(Strong::null(), |value| Arc::new(value).into())
+        },
+        _ => Strong::null(),
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_AssertTreeIsClean(root: &RawGeckoElement) {
+    if !cfg!(feature = "gecko_debug") {
+        panic!("Calling Servo_AssertTreeIsClean in release build");
+    }
+
+    let root = GeckoElement(root);
+    debug!("Servo_AssertTreeIsClean: ");
+    debug!("{:?}", ShowSubtreeData(root.as_node()));
+
+    fn assert_subtree_is_clean<'le>(el: GeckoElement<'le>) {
+        debug_assert!(
+            !el.has_dirty_descendants() && !el.has_animation_only_dirty_descendants(),
+            "{:?} has still dirty bit {:?} or animation-only dirty bit {:?}",
+            el,
+            el.has_dirty_descendants(),
+            el.has_animation_only_dirty_descendants()
+        );
+        for child in el.traversal_children() {
+            if let Some(child) = child.as_element() {
+                assert_subtree_is_clean(child);
+            }
+        }
+    }
+
+    assert_subtree_is_clean(root);
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_IsWorkerThread() -> bool {
+    thread_state::get().is_worker()
+}
+
+enum Offset {
+    Zero,
+    One,
+}
+
+fn fill_in_missing_keyframe_values(
+    all_properties: &LonghandIdSet,
+    timing_function: &ComputedTimingFunction,
+    longhands_at_offset: &LonghandIdSet,
+    offset: Offset,
+    keyframes: &mut nsTArray<structs::Keyframe>,
+) {
+    // Return early if all animated properties are already set.
+    if longhands_at_offset.contains_all(all_properties) {
+        return;
+    }
+
+    // Use auto for missing keyframes.
+    // FIXME: This may be a spec issue in css-animations-2 because the spec says the default
+    // keyframe-specific composite is replace, but web-animations-1 uses auto. Use auto now so we
+    // use the value of animation-composition of the element, for missing keyframes.
+    // https://github.com/w3c/csswg-drafts/issues/7476
+    let composition = structs::CompositeOperationOrAuto::Auto;
+    let keyframe = match offset {
+        Offset::Zero => unsafe {
+            Gecko_GetOrCreateInitialKeyframe(keyframes, timing_function, composition)
+        },
+        Offset::One => unsafe {
+            Gecko_GetOrCreateFinalKeyframe(keyframes, timing_function, composition)
+        },
+    };
+
+    // Append properties that have not been set at this offset.
+    for property in all_properties.iter() {
+        if !longhands_at_offset.contains(property) {
+            unsafe {
+                Gecko_AppendPropertyValuePair(
+                    &mut *(*keyframe).mPropertyValues,
+                    property.to_nscsspropertyid(),
+                );
+            }
+        }
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_StyleSet_GetKeyframesForName(
+    raw_data: &PerDocumentStyleData,
+    element: &RawGeckoElement,
+    style: &ComputedValues,
+    name: *mut nsAtom,
+    inherited_timing_function: &ComputedTimingFunction,
+    keyframes: &mut nsTArray<structs::Keyframe>,
+) -> bool {
+    use style::gecko_bindings::structs::CompositeOperationOrAuto;
+    use style::properties::longhands::animation_composition::single_value::computed_value::T as Composition;
+
+    debug_assert!(keyframes.len() == 0, "keyframes should be initially empty");
+
+    let element = GeckoElement(element);
+    let data = raw_data.borrow();
+    let name = Atom::from_raw(name);
+
+    let animation = match data.stylist.get_animation(&name, element) {
+        Some(animation) => animation,
+        None => return false,
+    };
+
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+
+    let mut properties_set_at_current_offset = LonghandIdSet::new();
+    let mut properties_set_at_start = LonghandIdSet::new();
+    let mut properties_set_at_end = LonghandIdSet::new();
+    let mut has_complete_initial_keyframe = false;
+    let mut has_complete_final_keyframe = false;
+    let mut current_offset = -1.;
+
+    let writing_mode = style.writing_mode;
+
+    // Iterate over the keyframe rules backwards so we can drop overridden
+    // properties (since declarations in later rules override those in earlier
+    // ones).
+    for step in animation.steps.iter().rev() {
+        if step.start_percentage.0 != current_offset {
+            properties_set_at_current_offset.clear();
+            current_offset = step.start_percentage.0;
+        }
+
+        // Override timing_function if the keyframe has an animation-timing-function.
+        let timing_function = match step.get_animation_timing_function(&guard) {
+            Some(val) => val.to_computed_value_without_context(),
+            None => (*inherited_timing_function).clone(),
+        };
+
+        // Override composite operation if the keyframe has an animation-composition.
+        let composition =
+            step.get_animation_composition(&guard)
+                .map_or(CompositeOperationOrAuto::Auto, |val| match val {
+                    Composition::Replace => CompositeOperationOrAuto::Replace,
+                    Composition::Add => CompositeOperationOrAuto::Add,
+                    Composition::Accumulate => CompositeOperationOrAuto::Accumulate,
+                });
+
+        // Look for an existing keyframe with the same offset, timing function, and compsition, or
+        // else add a new keyframe at the beginning of the keyframe array.
+        let keyframe = Gecko_GetOrCreateKeyframeAtStart(
+            keyframes,
+            step.start_percentage.0 as f32,
+            &timing_function,
+            composition,
+        );
+
+        match step.value {
+            KeyframesStepValue::ComputedValues => {
+                // In KeyframesAnimation::from_keyframes if there is no 0% or
+                // 100% keyframe at all, we will create a 'ComputedValues' step
+                // to represent that all properties animated by the keyframes
+                // animation should be set to the underlying computed value for
+                // that keyframe.
+                let mut seen = LonghandIdSet::new();
+                for property in animation.properties_changed.iter() {
+                    let property = property.to_physical(writing_mode);
+                    if seen.contains(property) {
+                        continue;
+                    }
+                    seen.insert(property);
+
+                    Gecko_AppendPropertyValuePair(
+                        &mut *(*keyframe).mPropertyValues,
+                        property.to_nscsspropertyid(),
+                    );
+                }
+                if current_offset == 0.0 {
+                    has_complete_initial_keyframe = true;
+                } else if current_offset == 1.0 {
+                    has_complete_final_keyframe = true;
+                }
+            },
+            KeyframesStepValue::Declarations { ref block } => {
+                let guard = block.read_with(&guard);
+
+                let mut custom_properties = PropertyDeclarationBlock::new();
+
+                // Filter out non-animatable properties and properties with
+                // !important.
+                //
+                // Also, iterate in reverse to respect the source order in case
+                // there are logical and physical longhands in the same block.
+                for declaration in guard.normal_declaration_iter().rev() {
+                    let id = declaration.id();
+
+                    let id = match id {
+                        PropertyDeclarationId::Longhand(id) => {
+                            // Skip the 'display' property because although it
+                            // is animatable from SMIL, it should not be
+                            // animatable from CSS Animations.
+                            if id == LonghandId::Display {
+                                continue;
+                            }
+
+                            if !id.is_animatable() {
+                                continue;
+                            }
+
+                            id.to_physical(writing_mode)
+                        },
+                        PropertyDeclarationId::Custom(..) => {
+                            custom_properties.push(declaration.clone(), Importance::Normal);
+                            continue;
+                        },
+                    };
+
+                    if properties_set_at_current_offset.contains(id) {
+                        continue;
+                    }
+
+                    let pair = Gecko_AppendPropertyValuePair(
+                        &mut *(*keyframe).mPropertyValues,
+                        id.to_nscsspropertyid(),
+                    );
+
+                    (*pair).mServoDeclarationBlock.set_arc(Arc::new(
+                        global_style_data
+                            .shared_lock
+                            .wrap(PropertyDeclarationBlock::with_one(
+                                declaration.to_physical(writing_mode),
+                                Importance::Normal,
+                            )),
+                    ));
+
+                    if current_offset == 0.0 {
+                        properties_set_at_start.insert(id);
+                    } else if current_offset == 1.0 {
+                        properties_set_at_end.insert(id);
+                    }
+                    properties_set_at_current_offset.insert(id);
+                }
+
+                if custom_properties.any_normal() {
+                    let pair = Gecko_AppendPropertyValuePair(
+                        &mut *(*keyframe).mPropertyValues,
+                        nsCSSPropertyID::eCSSPropertyExtra_variable,
+                    );
+
+                    (*pair).mServoDeclarationBlock.set_arc(Arc::new(
+                        global_style_data.shared_lock.wrap(custom_properties),
+                    ));
+                }
+            },
+        }
+    }
+
+    let mut properties_changed = LonghandIdSet::new();
+    for property in animation.properties_changed.iter() {
+        properties_changed.insert(property.to_physical(writing_mode));
+    }
+
+    // Append property values that are missing in the initial or the final keyframes.
+    if !has_complete_initial_keyframe {
+        fill_in_missing_keyframe_values(
+            &properties_changed,
+            inherited_timing_function,
+            &properties_set_at_start,
+            Offset::Zero,
+            keyframes,
+        );
+    }
+    if !has_complete_final_keyframe {
+        fill_in_missing_keyframe_values(
+            &properties_changed,
+            inherited_timing_function,
+            &properties_set_at_end,
+            Offset::One,
+            keyframes,
+        );
+    }
+    true
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_GetFontFaceRules(
+    raw_data: &PerDocumentStyleData,
+    rules: &mut ThinVec<structs::nsFontFaceRuleContainer>,
+) {
+    let data = raw_data.borrow();
+    debug_assert_eq!(rules.len(), 0);
+
+    // Reversed iterator because Gecko expects rules to appear sorted
+    // UserAgent first, Author last.
+    let font_face_iter = data
+        .stylist
+        .iter_extra_data_origins_rev()
+        .flat_map(|(d, o)| d.font_faces.iter().zip(iter::repeat(o)));
+
+    rules.extend(font_face_iter.map(|(&(ref rule, _layer_id), origin)| {
+        structs::nsFontFaceRuleContainer {
+            mRule: structs::RefPtr::from_arc(rule.clone()),
+            mOrigin: origin,
+        }
+    }))
+}
+
+// XXX Ideally this should return a Option<&LockedCounterStyleRule>,
+// but we cannot, because the value from AtomicRefCell::borrow() can only
+// live in this function, and thus anything derived from it cannot get the
+// same lifetime as raw_data in parameter. See bug 1451543.
+#[no_mangle]
+pub unsafe extern "C" fn Servo_StyleSet_GetCounterStyleRule(
+    raw_data: &PerDocumentStyleData,
+    name: *mut nsAtom,
+) -> *const LockedCounterStyleRule {
+    let data = raw_data.borrow();
+    Atom::with(name, |name| {
+        data.stylist
+            .iter_extra_data_origins()
+            .find_map(|(d, _)| d.counter_styles.get(name))
+            .map_or(ptr::null(), |rule| &**rule as *const _)
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_BuildFontFeatureValueSet(
+    raw_data: &PerDocumentStyleData,
+) -> *mut gfxFontFeatureValueSet {
+    let data = raw_data.borrow();
+
+    let has_rule = data
+        .stylist
+        .iter_extra_data_origins()
+        .any(|(d, _)| !d.font_feature_values.is_empty());
+
+    if !has_rule {
+        return ptr::null_mut();
+    }
+
+    let font_feature_values_iter = data
+        .stylist
+        .iter_extra_data_origins_rev()
+        .flat_map(|(d, _)| d.font_feature_values.iter());
+
+    let set = unsafe { Gecko_ConstructFontFeatureValueSet() };
+    for &(ref rule, _) in font_feature_values_iter {
+        rule.set_at_rules(set);
+    }
+    set
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_BuildFontPaletteValueSet(
+    raw_data: &PerDocumentStyleData,
+) -> *mut FontPaletteValueSet {
+    let data = raw_data.borrow();
+
+    let has_rule = data
+        .stylist
+        .iter_extra_data_origins()
+        .any(|(d, _)| !d.font_palette_values.is_empty());
+
+    if !has_rule {
+        return ptr::null_mut();
+    }
+
+    let font_palette_values_iter = data
+        .stylist
+        .iter_extra_data_origins_rev()
+        .flat_map(|(d, _)| d.font_palette_values.iter());
+
+    let set = unsafe { Gecko_ConstructFontPaletteValueSet() };
+    for &(ref rule, _) in font_palette_values_iter {
+        rule.to_gecko_palette_value_set(set);
+    }
+    set
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_ResolveForDeclarations(
+    raw_data: &PerDocumentStyleData,
+    parent_style_context: Option<&ComputedValues>,
+    declarations: &LockedDeclarationBlock,
+) -> Strong<ComputedValues> {
+    let doc_data = raw_data.borrow();
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    let guards = StylesheetGuards::same(&guard);
+
+    let parent_style = match parent_style_context {
+        Some(parent) => &*parent,
+        None => doc_data.default_computed_values(),
+    };
+
+    doc_data
+        .stylist
+        .compute_for_declarations::<GeckoElement>(&guards, parent_style, unsafe {
+            Arc::from_raw_addrefed(declarations)
+        })
+        .into()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_AddSizeOfExcludingThis(
+    malloc_size_of: GeckoMallocSizeOf,
+    malloc_enclosing_size_of: GeckoMallocSizeOf,
+    sizes: *mut ServoStyleSetSizes,
+    raw_data: &PerDocumentStyleData,
+) {
+    let data = raw_data.borrow_mut();
+    let mut ops = MallocSizeOfOps::new(
+        malloc_size_of.unwrap(),
+        Some(malloc_enclosing_size_of.unwrap()),
+        None,
+    );
+    let sizes = unsafe { sizes.as_mut() }.unwrap();
+    data.add_size_of(&mut ops, sizes);
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_UACache_AddSizeOf(
+    malloc_size_of: GeckoMallocSizeOf,
+    malloc_enclosing_size_of: GeckoMallocSizeOf,
+    sizes: *mut ServoStyleSetSizes,
+) {
+    let mut ops = MallocSizeOfOps::new(
+        malloc_size_of.unwrap(),
+        Some(malloc_enclosing_size_of.unwrap()),
+        None,
+    );
+    let sizes = unsafe { sizes.as_mut() }.unwrap();
+    add_size_of_ua_cache(&mut ops, sizes);
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_MightHaveAttributeDependency(
+    raw_data: &PerDocumentStyleData,
+    element: &RawGeckoElement,
+    local_name: *mut nsAtom,
+) -> bool {
+    let data = raw_data.borrow();
+    let element = GeckoElement(element);
+
+    unsafe {
+        AtomIdent::with(local_name, |atom| {
+            data.stylist.any_applicable_rule_data(element, |data| {
+                data.might_have_attribute_dependency(atom)
+            })
+        })
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_MightHaveNthOfIDDependency(
+    raw_data: &PerDocumentStyleData,
+    element: &RawGeckoElement,
+    old_id: *mut nsAtom,
+    new_id: *mut nsAtom,
+) -> bool {
+    let data = raw_data.borrow();
+    let element = GeckoElement(element);
+
+    data.stylist.any_applicable_rule_data(element, |data| {
+        [old_id, new_id]
+            .iter()
+            .filter(|id| !id.is_null())
+            .any(|id| unsafe {
+                AtomIdent::with(*id, |atom| data.might_have_nth_of_id_dependency(atom))
+            }) ||
+            data.might_have_nth_of_attribute_dependency(&AtomIdent(atom!("id")))
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_MightHaveNthOfClassDependency(
+    raw_data: &PerDocumentStyleData,
+    element: &RawGeckoElement,
+    snapshots: &ServoElementSnapshotTable,
+) -> bool {
+    let data = raw_data.borrow();
+    let element = GeckoElement(element);
+
+    data.stylist.any_applicable_rule_data(element, |data| {
+        classes_changed(&element, snapshots)
+            .iter()
+            .any(|atom| data.might_have_nth_of_class_dependency(atom)) ||
+            data.might_have_nth_of_attribute_dependency(&AtomIdent(atom!("class")))
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_MightHaveNthOfAttributeDependency(
+    raw_data: &PerDocumentStyleData,
+    element: &RawGeckoElement,
+    local_name: *mut nsAtom,
+) -> bool {
+    let data = raw_data.borrow();
+    let element = GeckoElement(element);
+
+    unsafe {
+        AtomIdent::with(local_name, |atom| {
+            data.stylist.any_applicable_rule_data(element, |data| {
+                data.might_have_nth_of_attribute_dependency(atom)
+            })
+        })
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_HasStateDependency(
+    raw_data: &PerDocumentStyleData,
+    element: &RawGeckoElement,
+    state: u64,
+) -> bool {
+    let element = GeckoElement(element);
+
+    let state = ElementState::from_bits_retain(state);
+    let data = raw_data.borrow();
+
+    data.stylist
+        .any_applicable_rule_data(element, |data| data.has_state_dependency(state))
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_HasNthOfStateDependency(
+    raw_data: &PerDocumentStyleData,
+    element: &RawGeckoElement,
+    state: u64,
+) -> bool {
+    let element = GeckoElement(element);
+
+    let state = ElementState::from_bits_retain(state);
+    let data = raw_data.borrow();
+
+    data.stylist
+        .any_applicable_rule_data(element, |data| data.has_nth_of_state_dependency(state))
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_StyleSet_HasDocumentStateDependency(
+    raw_data: &PerDocumentStyleData,
+    state: u64,
+) -> bool {
+    let state = DocumentState::from_bits_retain(state);
+    let data = raw_data.borrow();
+
+    data.stylist.has_document_state_dependency(state)
+}
+
+fn computed_or_resolved_value(
+    style: &ComputedValues,
+    prop: nsCSSPropertyID,
+    context: Option<&style::values::resolved::Context>,
+    value: &mut nsACString,
+) {
+    if let Ok(longhand) = LonghandId::from_nscsspropertyid(prop) {
+        return style
+            .computed_or_resolved_value(longhand, context, value)
+            .unwrap();
+    }
+
+    let shorthand =
+        ShorthandId::from_nscsspropertyid(prop).expect("Not a shorthand nor a longhand?");
+    let mut block = PropertyDeclarationBlock::new();
+    for longhand in shorthand.longhands() {
+        block.push(
+            style.computed_or_resolved_declaration(longhand, context),
+            Importance::Normal,
+        );
+    }
+    block.shorthand_to_css(shorthand, value).unwrap();
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_GetComputedValue(
+    style: &ComputedValues,
+    prop: nsCSSPropertyID,
+    value: &mut nsACString,
+) {
+    computed_or_resolved_value(style, prop, None, value)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_GetResolvedValue(
+    style: &ComputedValues,
+    prop: nsCSSPropertyID,
+    raw_data: &PerDocumentStyleData,
+    element: &RawGeckoElement,
+    value: &mut nsACString,
+) {
+    use style::values::resolved;
+
+    let data = raw_data.borrow();
+    let device = data.stylist.device();
+    let context = resolved::Context {
+        style,
+        device,
+        element_info: resolved::ResolvedElementInfo {
+            element: GeckoElement(element),
+        },
+    };
+
+    computed_or_resolved_value(style, prop, Some(&context), value)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_GetCustomPropertyValue(
+    computed_values: &ComputedValues,
+    name: &nsACString,
+    value: &mut nsACString,
+) -> bool {
+    let custom_properties = match computed_values.custom_properties() {
+        Some(p) => p,
+        None => return false,
+    };
+
+    let name = Atom::from(name.as_str_unchecked());
+    let computed_value = match custom_properties.get(&name) {
+        Some(v) => v,
+        None => return false,
+    };
+
+    computed_value.to_css(&mut CssWriter::new(value)).unwrap();
+    true
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_GetCustomPropertiesCount(computed_values: &ComputedValues) -> u32 {
+    match computed_values.custom_properties() {
+        Some(p) => p.len() as u32,
+        None => 0,
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_GetCustomPropertyNameAt(
+    computed_values: &ComputedValues,
+    index: u32,
+) -> *mut nsAtom {
+    let custom_properties = match computed_values.custom_properties() {
+        Some(p) => p,
+        None => return ptr::null_mut(),
+    };
+
+    let property_name = match custom_properties.get_index(index as usize) {
+        Some((key, _value)) => key,
+        None => return ptr::null_mut(),
+    };
+
+    property_name.as_ptr()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_CssUrl_IsLocalRef(url: &url::CssUrl) -> bool {
+    url.is_fragment()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ProcessInvalidations(
+    set: &PerDocumentStyleData,
+    element: &RawGeckoElement,
+    snapshots: *const ServoElementSnapshotTable,
+) {
+    debug_assert!(!snapshots.is_null());
+
+    let element = GeckoElement(element);
+    debug_assert!(element.has_snapshot());
+    debug_assert!(!element.handled_snapshot());
+
+    let mut data = element.mutate_data();
+    debug_assert!(data.is_some());
+
+    let global_style_data = &*GLOBAL_STYLE_DATA;
+    let guard = global_style_data.shared_lock.read();
+    let per_doc_data = set.borrow();
+    let shared_style_context = create_shared_context(
+        &global_style_data,
+        &guard,
+        &per_doc_data.stylist,
+        TraversalFlags::empty(),
+        unsafe { &*snapshots },
+    );
+    let mut data = data.as_mut().map(|d| &mut **d);
+
+    if let Some(ref mut data) = data {
+        // FIXME(emilio): Ideally we could share the nth-index-cache across all
+        // the elements?
+        let result = data.invalidate_style_if_needed(
+            element,
+            &shared_style_context,
+            None,
+            &mut NthIndexCache::default(),
+        );
+
+        if result.has_invalidated_siblings() {
+            let parent = element
+                .traversal_parent()
+                .expect("How could we invalidate siblings without a common parent?");
+            unsafe {
+                parent.set_dirty_descendants();
+                bindings::Gecko_NoteDirtySubtreeForInvalidation(parent.0);
+            }
+        } else if result.has_invalidated_descendants() {
+            unsafe { bindings::Gecko_NoteDirtySubtreeForInvalidation(element.0) };
+        } else if result.has_invalidated_self() {
+            unsafe { bindings::Gecko_NoteDirtyElement(element.0) };
+        }
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_HasPendingRestyleAncestor(
+    element: &RawGeckoElement,
+    may_need_to_flush_layout: bool,
+) -> bool {
+    let mut has_yet_to_be_styled = false;
+    let mut element = Some(GeckoElement(element));
+    while let Some(e) = element {
+        if e.has_any_animation() {
+            return true;
+        }
+
+        // If the element needs a frame, it means that we haven't styled it yet
+        // after it got inserted in the document, and thus we may need to do
+        // that for transitions and animations to trigger.
+        //
+        // This is a fast path in the common case, but `has_yet_to_be_styled` is
+        // the real check for this.
+        if e.needs_frame() {
+            return true;
+        }
+
+        let data = e.borrow_data();
+        if let Some(ref data) = data {
+            if !data.hint.is_empty() {
+                return true;
+            }
+            if has_yet_to_be_styled && !data.styles.is_display_none() {
+                return true;
+            }
+            // Ideally, DOM mutations wouldn't affect layout trees of siblings.
+            //
+            // In practice, this can happen because Gecko deals pretty badly
+            // with some kinds of content insertion and removals.
+            //
+            // If we may need to flush layout, we need frames to accurately
+            // determine whether we'll actually flush, so if we have to
+            // reconstruct we need to flush style, which is what will take care
+            // of ensuring that frames are constructed, even if the style itself
+            // is up-to-date.
+            if may_need_to_flush_layout && data.damage.contains(GeckoRestyleDamage::reconstruct()) {
+                return true;
+            }
+        }
+        has_yet_to_be_styled = data.is_none();
+
+        element = e.traversal_parent();
+    }
+    false
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_SelectorList_Parse(
+    selector_list: &nsACString,
+    is_chrome: bool,
+) -> *mut SelectorList {
+    use style::selector_parser::SelectorParser;
+
+    let url_data = UrlExtraData::from_ptr_ref(if is_chrome {
+        &DUMMY_CHROME_URL_DATA
+    } else {
+        &DUMMY_URL_DATA
+    });
+
+    let input = selector_list.as_str_unchecked();
+    let selector_list = match SelectorParser::parse_author_origin_no_namespace(&input, url_data) {
+        Ok(selector_list) => selector_list,
+        Err(..) => return ptr::null_mut(),
+    };
+
+    Box::into_raw(Box::new(selector_list))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_SelectorList_Drop(list: *mut SelectorList) {
+    let _ = Box::from_raw(list);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_IsValidCSSColor(value: &nsACString) -> bool {
+    let mut input = ParserInput::new(value.as_str_unchecked());
+    let mut input = Parser::new(&mut input);
+    let context = ParserContext::new(
+        Origin::Author,
+        dummy_url_data(),
+        Some(CssRuleType::Style),
+        ParsingMode::DEFAULT,
+        QuirksMode::NoQuirks,
+        /* namespaces = */ Default::default(),
+        None,
+        None,
+    );
+    specified::Color::is_valid(&context, &mut input)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_ComputeColor(
+    raw_data: Option<&PerDocumentStyleData>,
+    current_color: structs::nscolor,
+    value: &nsACString,
+    result_color: &mut structs::nscolor,
+    was_current_color: *mut bool,
+    loader: *mut Loader,
+) -> bool {
+    let mut input = ParserInput::new(value.as_str_unchecked());
+    let mut input = Parser::new(&mut input);
+    let reporter = loader.as_mut().and_then(|loader| {
+        // Make an ErrorReporter that will report errors as being "from DOM".
+        ErrorReporter::new(ptr::null_mut(), loader, ptr::null_mut())
+    });
+
+    let context = ParserContext::new(
+        Origin::Author,
+        dummy_url_data(),
+        Some(CssRuleType::Style),
+        ParsingMode::DEFAULT,
+        QuirksMode::NoQuirks,
+        /* namespaces = */ Default::default(),
+        reporter.as_ref().map(|e| e as &dyn ParseErrorReporter),
+        None,
+    );
+
+    let data;
+    let device = match raw_data {
+        Some(d) => {
+            data = d.borrow();
+            Some(data.stylist.device())
+        },
+        None => None,
+    };
+
+    let computed = match specified::Color::parse_and_compute(&context, &mut input, device) {
+        Some(c) => c,
+        None => return false,
+    };
+
+    let current_color = style::gecko::values::convert_nscolor_to_absolute_color(current_color);
+    if !was_current_color.is_null() {
+        *was_current_color = computed.is_currentcolor();
+    }
+
+    let rgba = computed.resolve_to_absolute(&current_color);
+    *result_color = style::gecko::values::convert_absolute_color_to_nscolor(&rgba);
+    true
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ResolveColor(
+    color: &computed::Color,
+    foreground: &style::color::AbsoluteColor,
+) -> style::color::AbsoluteColor {
+    color.resolve_to_absolute(foreground)
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ConvertColorSpace(
+    color: &AbsoluteColor,
+    color_space: ColorSpace,
+) -> AbsoluteColor {
+    color.to_color_space(color_space)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_IntersectionObserverRootMargin_Parse(
+    value: &nsACString,
+    result: *mut IntersectionObserverRootMargin,
+) -> bool {
+    let value = value.as_str_unchecked();
+    let result = result.as_mut().unwrap();
+
+    let mut input = ParserInput::new(&value);
+    let mut parser = Parser::new(&mut input);
+
+    let url_data = dummy_url_data();
+    let context = ParserContext::new(
+        Origin::Author,
+        url_data,
+        Some(CssRuleType::Style),
+        ParsingMode::DEFAULT,
+        QuirksMode::NoQuirks,
+        /* namespaces = */ Default::default(),
+        None,
+        None,
+    );
+
+    let margin = parser.parse_entirely(|p| IntersectionObserverRootMargin::parse(&context, p));
+    match margin {
+        Ok(margin) => {
+            *result = margin;
+            true
+        },
+        Err(..) => false,
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_IntersectionObserverRootMargin_ToString(
+    root_margin: &IntersectionObserverRootMargin,
+    result: &mut nsACString,
+) {
+    let mut writer = CssWriter::new(result);
+    root_margin.to_css(&mut writer).unwrap();
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ParseTransformIntoMatrix(
+    value: &nsACString,
+    contain_3d: &mut bool,
+    result: &mut structs::Matrix4x4Components,
+) -> bool {
+    use style::properties::longhands::transform;
+
+    let string = unsafe { value.as_str_unchecked() };
+    let mut input = ParserInput::new(&string);
+    let mut parser = Parser::new(&mut input);
+    let context = ParserContext::new(
+        Origin::Author,
+        unsafe { dummy_url_data() },
+        Some(CssRuleType::Style),
+        ParsingMode::DEFAULT,
+        QuirksMode::NoQuirks,
+        /* namespaces = */ Default::default(),
+        None,
+        None,
+    );
+
+    let transform = match parser.parse_entirely(|t| transform::parse(&context, t)) {
+        Ok(t) => t,
+        Err(..) => return false,
+    };
+
+    let (m, is_3d) = match transform.to_transform_3d_matrix(None) {
+        Ok(result) => result,
+        Err(..) => return false,
+    };
+
+    *result = m.to_array();
+    *contain_3d = is_3d;
+    true
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_ParseFontShorthandForMatching(
+    value: &nsACString,
+    data: *mut URLExtraData,
+    family: &mut FontFamilyList,
+    style: &mut FontStyle,
+    stretch: &mut FontStretch,
+    weight: &mut FontWeight,
+    size: Option<&mut f32>,
+) -> bool {
+    use style::properties::shorthands::font;
+    use style::values::generics::font::FontStyle as GenericFontStyle;
+    use style::values::specified::font as specified;
+
+    let string = value.as_str_unchecked();
+    let mut input = ParserInput::new(&string);
+    let mut parser = Parser::new(&mut input);
+    let url_data = UrlExtraData::from_ptr_ref(&data);
+    let context = ParserContext::new(
+        Origin::Author,
+        url_data,
+        Some(CssRuleType::FontFace),
+        ParsingMode::DEFAULT,
+        QuirksMode::NoQuirks,
+        /* namespaces = */ Default::default(),
+        None,
+        None,
+    );
+
+    let font = match parser.parse_entirely(|f| font::parse_value(&context, f)) {
+        Ok(f) => f,
+        Err(..) => return false,
+    };
+
+    // The system font is not acceptable, so we return false.
+    match font.font_family {
+        specified::FontFamily::Values(list) => *family = list,
+        specified::FontFamily::System(_) => return false,
+    }
+
+    let specified_font_style = match font.font_style {
+        specified::FontStyle::Specified(ref s) => s,
+        specified::FontStyle::System(_) => return false,
+    };
+
+    *style = match *specified_font_style {
+        GenericFontStyle::Normal => FontStyle::NORMAL,
+        GenericFontStyle::Italic => FontStyle::ITALIC,
+        GenericFontStyle::Oblique(ref angle) => FontStyle::oblique(angle.degrees()),
+    };
+
+    *stretch = match font.font_stretch {
+        specified::FontStretch::Keyword(ref k) => k.compute(),
+        specified::FontStretch::Stretch(ref p) => FontStretch::from_percentage(p.0.get()),
+        specified::FontStretch::System(_) => return false,
+    };
+
+    *weight = match font.font_weight {
+        specified::FontWeight::Absolute(w) => w.compute(),
+        // Resolve relative font weights against the initial of font-weight
+        // (normal, which is equivalent to 400).
+        specified::FontWeight::Bolder => FontWeight::normal().bolder(),
+        specified::FontWeight::Lighter => FontWeight::normal().lighter(),
+        specified::FontWeight::System(_) => return false,
+    };
+
+    // XXX This is unfinished; see values::specified::FontSize::ToComputedValue
+    // for a more complete implementation (but we can't use it as-is).
+    if let Some(size) = size {
+        *size = match font.font_size {
+            specified::FontSize::Length(lp) => {
+                use style::values::generics::transform::ToAbsoluteLength;
+                match lp.to_pixel_length(None) {
+                    Ok(len) => len,
+                    Err(..) => return false,
+                }
+            },
+            // Map absolute-size keywords to sizes.
+            specified::FontSize::Keyword(info) => {
+                // TODO: Maybe get a meaningful quirks / base size from the caller?
+                let quirks_mode = QuirksMode::NoQuirks;
+                info.kw
+                    .to_length_without_context(
+                        quirks_mode,
+                        computed::Length::new(specified::FONT_MEDIUM_PX),
+                    )
+                    .0
+                    .px()
+            },
+            // smaller, larger not currently supported
+            specified::FontSize::Smaller |
+            specified::FontSize::Larger |
+            specified::FontSize::System(_) => {
+                return false;
+            },
+        };
+    }
+
+    true
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_SourceSizeList_Parse(value: &nsACString) -> *mut SourceSizeList {
+    let value = value.as_str_unchecked();
+    let mut input = ParserInput::new(value);
+    let mut parser = Parser::new(&mut input);
+
+    let context = ParserContext::new(
+        Origin::Author,
+        dummy_url_data(),
+        Some(CssRuleType::Style),
+        ParsingMode::DEFAULT,
+        QuirksMode::NoQuirks,
+        /* namespaces = */ Default::default(),
+        None,
+        None,
+    );
+
+    // NB: Intentionally not calling parse_entirely.
+    let list = SourceSizeList::parse(&context, &mut parser);
+    Box::into_raw(Box::new(list))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_SourceSizeList_Evaluate(
+    raw_data: &PerDocumentStyleData,
+    list: Option<&SourceSizeList>,
+) -> i32 {
+    let doc_data = raw_data.borrow();
+    let device = doc_data.stylist.device();
+    let quirks_mode = doc_data.stylist.quirks_mode();
+
+    let result = match list {
+        Some(list) => list.evaluate(device, quirks_mode),
+        None => SourceSizeList::empty().evaluate(device, quirks_mode),
+    };
+
+    result.0
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_SourceSizeList_Drop(list: *mut SourceSizeList) {
+    let _ = Box::from_raw(list);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_InvalidateStyleForDocStateChanges(
+    root: &RawGeckoElement,
+    document_style: &PerDocumentStyleData,
+    non_document_styles: &nsTArray<&AuthorStyles>,
+    states_changed: u64,
+) {
+    use style::invalidation::element::document_state::DocumentStateInvalidationProcessor;
+    use style::invalidation::element::invalidator::TreeStyleInvalidator;
+
+    let document_data = document_style.borrow();
+
+    let iter = document_data
+        .stylist
+        .iter_origins()
+        .map(|(data, _origin)| data)
+        .chain(
+            non_document_styles
+                .iter()
+                .map(|author_styles| &*author_styles.data),
+        );
+
+    let mut nth_index_cache = Default::default();
+    let root = GeckoElement(root);
+    let mut processor = DocumentStateInvalidationProcessor::new(
+        iter,
+        DocumentState::from_bits_retain(states_changed),
+        &mut nth_index_cache,
+        root.as_node().owner_doc().quirks_mode(),
+    );
+
+    let result =
+        TreeStyleInvalidator::new(root, /* stack_limit_checker = */ None, &mut processor)
+            .invalidate();
+
+    debug_assert!(!result.has_invalidated_siblings(), "How in the world?");
+    if result.has_invalidated_descendants() {
+        bindings::Gecko_NoteDirtySubtreeForInvalidation(root.0);
+    } else if result.has_invalidated_self() {
+        bindings::Gecko_NoteDirtyElement(root.0);
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_PseudoClass_GetStates(name: &nsACString) -> u64 {
+    let name = name.as_str_unchecked();
+    match NonTSPseudoClass::parse_non_functional(name) {
+        None => 0,
+        // Ignore :any-link since it contains both visited and unvisited state.
+        Some(NonTSPseudoClass::AnyLink) => 0,
+        Some(pseudo_class) => pseudo_class.state_flag().bits(),
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_UseCounters_Create() -> *mut UseCounters {
+    Box::into_raw(Box::<UseCounters>::default())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_UseCounters_Drop(c: *mut UseCounters) {
+    let _ = Box::from_raw(c);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_UseCounters_Merge(
+    doc_counters: &UseCounters,
+    sheet_counters: &UseCounters,
+) {
+    doc_counters.merge(sheet_counters)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_IsPropertyIdRecordedInUseCounter(
+    use_counters: &UseCounters,
+    id: nsCSSPropertyID,
+) -> bool {
+    let id = NonCustomPropertyId::from_nscsspropertyid(id).unwrap();
+    use_counters.non_custom_properties.recorded(id)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_IsUnknownPropertyRecordedInUseCounter(
+    use_counters: &UseCounters,
+    p: CountedUnknownProperty,
+) -> bool {
+    use_counters.counted_unknown_properties.recorded(p)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_IsCssPropertyRecordedInUseCounter(
+    use_counters: &UseCounters,
+    property: &nsACString,
+    known_prop: *mut bool,
+) -> bool {
+    *known_prop = false;
+
+    let prop_name = property.as_str_unchecked();
+    if let Ok(p) = PropertyId::parse_unchecked_for_testing(prop_name) {
+        if let Some(id) = p.non_custom_id() {
+            *known_prop = true;
+            return use_counters.non_custom_properties.recorded(id);
+        }
+    }
+
+    if let Some(p) = CountedUnknownProperty::parse_for_testing(prop_name) {
+        *known_prop = true;
+        return use_counters.counted_unknown_properties.recorded(p);
+    }
+
+    false
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_SharedMemoryBuilder_Create(
+    buffer: *mut u8,
+    len: usize,
+) -> *mut SharedMemoryBuilder {
+    Box::into_raw(Box::new(SharedMemoryBuilder::new(buffer, len)))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_SharedMemoryBuilder_AddStylesheet(
+    builder: &mut SharedMemoryBuilder,
+    contents: &StylesheetContents,
+    error_message: &mut nsACString,
+) -> *const LockedCssRules {
+    // Assert some things we assume when we create a style sheet from shared
+    // memory.
+    debug_assert_eq!(contents.origin, Origin::UserAgent);
+    debug_assert_eq!(contents.quirks_mode, QuirksMode::NoQuirks);
+    debug_assert!(contents.source_map_url.read().is_none());
+    debug_assert!(contents.source_url.read().is_none());
+
+    match builder.write(&contents.rules) {
+        Ok(rules_ptr) => &**rules_ptr,
+        Err(message) => {
+            error_message.assign(&message);
+            ptr::null()
+        },
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_SharedMemoryBuilder_GetLength(
+    builder: &SharedMemoryBuilder,
+) -> usize {
+    builder.len()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_SharedMemoryBuilder_Drop(builder: *mut SharedMemoryBuilder) {
+    let _ = Box::from_raw(builder);
+}
+
+/// Returns a unique pointer to a clone of the shape image.
+///
+/// Probably temporary, as we move more stuff to cbindgen.
+#[no_mangle]
+#[must_use]
+pub unsafe extern "C" fn Servo_CloneBasicShape(
+    v: &computed::basic_shape::BasicShape,
+) -> *mut computed::basic_shape::BasicShape {
+    Box::into_raw(Box::new(v.clone()))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_StyleArcSlice_EmptyPtr() -> *mut c_void {
+    style_traits::arc_slice::ArcSlice::<u64>::leaked_empty_ptr()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_LoadData_GetLazy(
+    source: &url::LoadDataSource,
+) -> *const url::LoadData {
+    source.get()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_LengthPercentage_ToCss(
+    lp: &computed::LengthPercentage,
+    result: &mut nsACString,
+) {
+    lp.to_css(&mut CssWriter::new(result)).unwrap();
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_FontStyle_ToCss(s: &FontStyle, result: &mut nsACString) {
+    s.to_css(&mut CssWriter::new(result)).unwrap()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_FontWeight_ToCss(w: &FontWeight, result: &mut nsACString) {
+    w.to_css(&mut CssWriter::new(result)).unwrap()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_FontStretch_ToCss(s: &FontStretch, result: &mut nsACString) {
+    s.to_css(&mut CssWriter::new(result)).unwrap()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_FontStretch_SerializeKeyword(
+    s: &FontStretch,
+    result: &mut nsACString,
+) -> bool {
+    let kw = match s.as_keyword() {
+        Some(kw) => kw,
+        None => return false,
+    };
+    kw.to_css(&mut CssWriter::new(result)).unwrap();
+    true
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_CursorKind_Parse(
+    cursor: &nsACString,
+    result: &mut computed::ui::CursorKind,
+) -> bool {
+    match computed::ui::CursorKind::from_ident(cursor.as_str_unchecked()) {
+        Ok(c) => {
+            *result = c;
+            true
+        },
+        Err(..) => false,
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_FontFamily_Generic(generic: GenericFontFamily) -> &'static FontFamily {
+    FontFamily::generic(generic)
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_FontFamily_ForSystemFont(name: &nsACString, out: &mut FontFamily) {
+    *out = FontFamily::for_system_font(&name.to_utf8());
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_FontFamilyList_WithNames(
+    names: &nsTArray<computed::font::SingleFontFamily>,
+    out: &mut FontFamilyList,
+) {
+    *out = FontFamilyList {
+        list: style_traits::arc_slice::ArcSlice::from_iter(names.iter().cloned()),
+    };
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_GenericFontFamily_Parse(input: &nsACString) -> GenericFontFamily {
+    let context = ParserContext::new(
+        Origin::Author,
+        unsafe { dummy_url_data() },
+        Some(CssRuleType::Style),
+        ParsingMode::DEFAULT,
+        QuirksMode::NoQuirks,
+        /* namespaces = */ Default::default(),
+        None,
+        None,
+    );
+    let value = input.to_utf8();
+    let mut input = ParserInput::new(&value);
+    let mut input = Parser::new(&mut input);
+    GenericFontFamily::parse(&context, &mut input).unwrap_or(GenericFontFamily::None)
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ColorScheme_Parse(input: &nsACString, out: &mut u8) -> bool {
+    use style::values::specified::ColorScheme;
+
+    let context = ParserContext::new(
+        Origin::Author,
+        unsafe { dummy_url_data() },
+        Some(CssRuleType::Style),
+        ParsingMode::DEFAULT,
+        QuirksMode::NoQuirks,
+        /* namespaces = */ Default::default(),
+        None,
+        None,
+    );
+    let input = unsafe { input.as_str_unchecked() };
+    let mut input = ParserInput::new(&input);
+    let mut input = Parser::new(&mut input);
+    let scheme = match input.parse_entirely(|i| ColorScheme::parse(&context, i)) {
+        Ok(scheme) => scheme,
+        Err(..) => return false,
+    };
+    *out = scheme.raw_bits();
+    true
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_LayerBlockRule_GetName(rule: &LayerBlockRule, result: &mut nsACString) {
+    if let Some(ref name) = rule.name {
+        name.to_css(&mut CssWriter::new(result)).unwrap()
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_LayerStatementRule_GetNameCount(rule: &LayerStatementRule) -> usize {
+    rule.names.len()
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_LayerStatementRule_GetNameAt(
+    rule: &LayerStatementRule,
+    index: usize,
+    result: &mut nsACString,
+) {
+    if let Some(ref name) = rule.names.get(index) {
+        name.to_css(&mut CssWriter::new(result)).unwrap()
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn Servo_InvalidateForViewportUnits(
+    document_style: &PerDocumentStyleData,
+    root: &RawGeckoElement,
+    dynamic_only: bool,
+) {
+    let document_data = document_style.borrow();
+    let device = document_data.stylist.device();
+
+    if !device.used_viewport_size() {
+        return;
+    }
+
+    if dynamic_only && !device.used_dynamic_viewport_size() {
+        return;
+    }
+
+    if style::invalidation::viewport_units::invalidate(GeckoElement(root)) {
+        // The invalidation machinery propagates the bits up, but we still need
+        // to tell the Gecko restyle root machinery about it.
+        bindings::Gecko_NoteDirtySubtreeForInvalidation(root);
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_InterpolateColor(
+    interpolation: ColorInterpolationMethod,
+    left: &AbsoluteColor,
+    right: &AbsoluteColor,
+    progress: f32,
+) -> AbsoluteColor {
+    style::color::mix::mix(
+        interpolation,
+        left,
+        progress,
+        right,
+        1.0 - progress,
+        /* normalize_weights = */ false,
+    )
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_EasingFunctionAt(
+    easing_function: &ComputedTimingFunction,
+    progress: f64,
+    before_flag: BeforeFlag,
+) -> f64 {
+    easing_function.calculate_output(progress, before_flag, 1e-7)
+}
+
+fn parse_no_context<'i, F, R>(string: &'i str, parse: F) -> Result<R, ()>
+where
+    F: FnOnce(&ParserContext, &mut Parser<'i, '_>) -> Result<R, ParseError<'i>>,
+{
+    let context = ParserContext::new(
+        Origin::Author,
+        unsafe { dummy_url_data() },
+        None,
+        ParsingMode::DEFAULT,
+        QuirksMode::NoQuirks,
+        /* namespaces = */ Default::default(),
+        None,
+        None,
+    );
+    let mut input = ParserInput::new(string);
+    Parser::new(&mut input)
+        .parse_entirely(|i| parse(&context, i))
+        .map_err(|_| ())
+}
+
+#[no_mangle]
+pub extern "C" fn Servo_ParseAbsoluteLength(len: &nsACString, out: &mut f32) -> bool {
+    let value = parse_no_context(unsafe { len.as_str_unchecked() }, specified::Length::parse)
+        .and_then(|p| p.to_computed_pixel_length_without_context());
+    match value {
+        Ok(v) => {
+            *out = v;
+            true
+        },
+        Err(..) => false,
+    }
+}