Attachment #8822399 for bug #1298588

Attachment #8822399: part 12. Compile some bits that call ComputedValues::initial_values only for servo, not stylo for bug #1298588

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





//! Selector matching.

use {Atom, LocalName};
use data::ComputedStyle;
use dom::PresentationalHintsSynthetizer;
use element_state::*;
use error_reporting::StdoutErrorReporter;
use keyframes::KeyframesAnimation;
use media_queries::Device;
#[cfg(feature = "servo")]
use media_queries::MediaType;
use parking_lot::RwLock;
use properties::{self, CascadeFlags, ComputedValues, INHERIT_ALL, Importance};
use properties::{PropertyDeclaration, PropertyDeclarationBlock};
use quickersort::sort_by;
use restyle_hints::{RestyleHint, DependencySet};
use rule_tree::{RuleTree, StrongRuleNode, StyleSource};
use selector_parser::{ElementExt, SelectorImpl, PseudoElement, Snapshot};
use selectors::Element;

use std::collections::HashMap;
use std::fmt;
use std::hash::BuildHasherDefault;
use std::hash::Hash;
use std::slice;
use std::sync::Arc;
use style_traits::viewport::ViewportConstraints;
use stylesheets::{CssRule, Origin, StyleRule, Stylesheet, UserAgentStylesheets};
#[cfg(feature = "servo")]
use viewport::{self, MaybeNew, ViewportRule};

pub type FnvHashMap<K, V> = HashMap<K, V, BuildHasherDefault<::fnv::FnvHasher>>;

/// This structure holds all the selectors and device characteristics
/// for a given document. The selectors are converted into `Rule`s
/// (defined in rust-selectors), and introduced in a `SelectorMap`
/// depending on the pseudo-element (see `PerPseudoElementSelectorMap`),

                                default,
                                None,
                                Box::new(StdoutErrorReporter),
                                CascadeFlags::empty());

        Some(ComputedStyle::new(rule_node, Arc::new(computed)))
    }

    #[cfg(feature = "servo")]
    pub fn set_device(&mut self, mut device: Device, stylesheets: &[Arc<Stylesheet>]) {
        let cascaded_rule = ViewportRule {
            declarations: viewport::Cascade::from_stylesheets(stylesheets, &device).finish(),
        };

        self.viewport_constraints = ViewportConstraints::maybe_new(device.viewport_size, &cascaded_rule);
        if let Some(ref constraints) = self.viewport_constraints {
            device = Device::new(MediaType::Screen, constraints.size);





 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

//! The [`@viewport`][at] at-rule and [`meta`][meta] element.
//!
//! [at]: https://drafts.csswg.org/css-device-adapt/#atviewport-rule
//! [meta]: https://drafts.csswg.org/css-device-adapt/#viewport-meta

#[cfg(feature = "servo")]
use app_units::Au;
use cssparser::{AtRuleParser, DeclarationListParser, DeclarationParser, Parser, parse_important};
use cssparser::ToCss as ParserToCss;
#[cfg(feature = "servo")]
use euclid::scale_factor::ScaleFactor;
use euclid::size::TypedSize2D;
#[cfg(feature = "servo")]
use euclid::size::Size2D;
use media_queries::Device;
use parser::{ParserContext, log_css_error};
#[cfg(feature = "servo")]
use properties::ComputedValues;
use std::ascii::AsciiExt;
use std::borrow::Cow;
use std::fmt;
use std::iter::Enumerate;
use std::str::Chars;
use style_traits::{ToCss, ViewportPx};
use style_traits::viewport::{Orientation, UserZoom, ViewportConstraints, Zoom};
use stylesheets::{Stylesheet, Origin};
#[cfg(feature = "servo")]
use values::computed::{Context, ToComputedValue};
use values::specified::{Length, LengthOrPercentageOrAuto, ViewportPercentageLength};

macro_rules! declare_viewport_descriptor {
    ( $( $variant_name: expr => $variant: ident($data: ident), )+ ) => {
         declare_viewport_descriptor_inner!([] [ $( $variant_name => $variant($data), )+ ] 0);
    };
}

}

pub trait MaybeNew {
    fn maybe_new(initial_viewport: TypedSize2D<f32, ViewportPx>,
                     rule: &ViewportRule)
                     -> Option<ViewportConstraints>;
}

#[cfg(feature = "servo")]
impl MaybeNew for ViewportConstraints {
    fn maybe_new(initial_viewport: TypedSize2D<f32, ViewportPx>,
                 rule: &ViewportRule)
                 -> Option<ViewportConstraints>
    {
        use std::cmp;

        if rule.declarations.is_empty() {

Return to bug 1298588