Attachment #8822392 for bug #1298588

Attachment #8822392: part 7. Stop using initial_values in general in Gecko glue code for bug #1298588

View | Details | Raw Unified | Return to bug 1298588
Collapse All | Expand All





#[no_mangle]
pub extern "C" fn Servo_ResolvePseudoStyle(element: RawGeckoElementBorrowed,
                                           pseudo_tag: *mut nsIAtom, is_probe: bool,
                                           raw_data: RawServoStyleSetBorrowed)
     -> ServoComputedValuesStrong
{
    let element = GeckoElement(element);
    let data = unsafe { element.ensure_data() }.borrow_mut();
    let doc_data = PerDocumentStyleData::from_ffi(raw_data);

    // FIXME(bholley): Assert against this.
    if data.get_styles().is_none() {
        error!("Calling Servo_ResolvePseudoStyle on unstyled element");
        return if is_probe {
            Strong::null()
        } else {
            doc_data.borrow().default_computed_values.clone().into_strong()
        };
    }

    let doc_data = PerDocumentStyleData::from_ffi(raw_data);
    match get_pseudo_style(element, pseudo_tag, data.styles(), doc_data) {
        Some(values) => values.into_strong(),
        None if !is_probe => data.styles().primary.values.clone().into_strong(),
        None => Strong::null(),
    }
}

fn get_pseudo_style(element: GeckoElement, pseudo_tag: *mut nsIAtom,

                                     raw_data: RawServoStyleSetBorrowed,
                                     consume: structs::ConsumeStyleBehavior,
                                     compute: structs::LazyComputeBehavior) -> ServoComputedValuesStrong
{
    let element = GeckoElement(element);
    debug!("Servo_ResolveStyle: {:?}, consume={:?}, compute={:?}", element, consume, compute);

    let mut data = unsafe { element.ensure_data() }.borrow_mut();
    let per_doc_data = PerDocumentStyleData::from_ffi(raw_data).borrow();

    if compute == structs::LazyComputeBehavior::Allow {
        let should_compute = !data.has_current_styles();
        if should_compute {
            debug!("Performing manual style computation");
            if let Some(parent) = element.parent_element() {
                if parent.borrow_data().map_or(true, |d| !d.has_current_styles()) {
                    error!("Attempting manual style computation with unstyled parent");
                    return per_doc_data.default_computed_values.clone().into_strong()
                }
            }

            let per_doc_data = PerDocumentStyleData::from_ffi(raw_data).borrow_mut();
            let shared_style_context = create_shared_context(&per_doc_data);
            let traversal = RecalcStyleOnly::new(shared_style_context);

            let mut traversal_data = PerLevelTraversalData {
                current_dom_depth: None,
            };

            let mut tlc = ThreadLocalStyleContext::new(traversal.shared_context());

            if element.first_child_element().is_some() {
                unsafe { element.set_dirty_descendants() };
            }
        }
    }

    if !data.has_current_styles() {
        error!("Resolving style on unstyled element with lazy computation forbidden.");
        return per_doc_data.default_computed_values.clone().into_strong();
    }

    let values = data.styles().primary.values.clone();

    if consume == structs::ConsumeStyleBehavior::Consume {
        // FIXME(bholley): Once we start storing style data on frames, we'll want to
        // drop the data here instead.
        data.persist();

Return to bug 1298588