Bug 1298588 part 13. Make sure Device has a ComputedValues for stylo. r=bholley

components/style/gecko/data.rs

@@ -81,7 +81,12 @@ impl PerDocumentStyleData {
     pub fn new(pres_context: RawGeckoPresContextBorrowed) -> Self {
         // FIXME(bholley): Real window size.
         let window_size: TypedSize2D<f32, ViewportPx> = TypedSize2D::new(800.0, 600.0);
-        let device = Device::new(MediaType::Screen, window_size);
+        let default_computed_values = ComputedValues::default_values(pres_context);
+
+        // FIXME(bz): We're going to need to either update the computed values
+        // in the Stylist's Device or give the Stylist a new Device when our
+        // default_computed_values changes.
+        let device = Device::new(MediaType::Screen, window_size, &default_computed_values);
 
         let (new_anims_sender, new_anims_receiver) = channel();
 
@@ -101,7 +106,7 @@ impl PerDocumentStyleData {
                 rayon::ThreadPool::new(configuration).ok()
             },
             num_threads: *NUM_THREADS,
-            default_computed_values: ComputedValues::default_values(pres_context),
+            default_computed_values: default_computed_values,
         }))
     }
 

components/style/media_queries.rs

@@ -10,14 +10,16 @@ use Atom;
 use app_units::Au;
 use cssparser::{Delimiter, Parser, Token};
 use euclid::size::{Size2D, TypedSize2D};
+use properties::ComputedValues;
 use serialize_comma_separated_list;
 use std::ascii::AsciiExt;
 use std::fmt;
+#[cfg(feature = "gecko")]
+use std::sync::Arc;
 use style_traits::{ToCss, ViewportPx};
 use values::computed::{self, ToComputedValue};
 use values::specified;
 
-
 #[derive(Debug, PartialEq)]
 #[cfg_attr(feature = "servo", derive(HeapSizeOf))]
 pub struct MediaList {
@@ -47,10 +49,18 @@ pub enum Range<T> {
 }
 
 impl Range<specified::Length> {
-    fn to_computed_range(&self, viewport_size: Size2D<Au>) -> Range<Au> {
+    fn to_computed_range(&self, viewport_size: Size2D<Au>, default_values: &ComputedValues) -> Range<Au> {
         // http://dev.w3.org/csswg/mediaqueries3/#units
         // em units are relative to the initial font-size.
-        let context = computed::Context::initial(viewport_size, false);
+        let context = computed::Context {
+            is_root_element: false,
+            viewport_size: viewport_size,
+            inherited_style: default_values,
+            // This cloning business is kind of dumb.... It's because Context
+            // insists on having an actual ComputedValues inside itself.
+            style: default_values.clone(),
+            font_metrics_provider: None
+        };
 
         match *self {
             Range::Min(ref width) => Range::Min(width.to_computed_value(&context)),
@@ -225,9 +235,12 @@ impl MediaType {
 pub struct Device {
     pub media_type: MediaType,
     pub viewport_size: TypedSize2D<f32, ViewportPx>,
+    #[cfg(feature = "gecko")]
+    pub default_values: Arc<ComputedValues>,
 }
 
 impl Device {
+    #[cfg(feature = "servo")]
     pub fn new(media_type: MediaType, viewport_size: TypedSize2D<f32, ViewportPx>) -> Device {
         Device {
             media_type: media_type,
@@ -235,6 +248,26 @@ impl Device {
         }
     }
 
+    #[cfg(feature = "servo")]
+    pub fn default_values(&self) -> &ComputedValues {
+        ComputedValues::initial_values()
+    }
+
+    #[cfg(feature = "gecko")]
+    pub fn new(media_type: MediaType, viewport_size: TypedSize2D<f32, ViewportPx>,
+               default_values: &Arc<ComputedValues>) -> Device {
+        Device {
+            media_type: media_type,
+            viewport_size: viewport_size,
+            default_values: default_values.clone(),
+        }
+    }
+
+    #[cfg(feature = "gecko")]
+    pub fn default_values(&self) -> &ComputedValues {
+        &*self.default_values
+    }
+
     #[inline]
     pub fn au_viewport_size(&self) -> Size2D<Au> {
         Size2D::new(Au::from_f32_px(self.viewport_size.width),
@@ -337,7 +370,7 @@ impl MediaList {
             let query_match = media_match && mq.expressions.iter().all(|expression| {
                 match *expression {
                     Expression::Width(ref value) =>
-                        value.to_computed_range(viewport_size).evaluate(viewport_size.width),
+                        value.to_computed_range(viewport_size, device.default_values()).evaluate(viewport_size.width),
                 }
             });
 

components/style/values/computed/mod.rs

@@ -62,20 +62,6 @@ impl<'a> Context<'a> {
     pub fn style(&self) -> &ComputedValues { &self.style }
     /// A mutable reference to the current style.
     pub fn mutate_style(&mut self) -> &mut ComputedValues { &mut self.style }
-
-    /// Creates a dummy computed context for use in multiple places, like
-    /// evaluating media queries.
-    pub fn initial(viewport_size: Size2D<Au>, is_root_element: bool) -> Self {
-        let initial_style = ComputedValues::initial_values();
-        // FIXME: Enforce a font metrics provider.
-        Context {
-            is_root_element: is_root_element,
-            viewport_size: viewport_size,
-            inherited_style: initial_style,
-            style: initial_style.clone(),
-            font_metrics_provider: None,
-        }
-    }
 }
 
 /// A trait to represent the conversion between computed and specified values.

ports/geckolib/glue.rs

@@ -623,6 +623,7 @@ pub extern "C" fn Servo_StyleSet_RecomputeDefaultStyles(
   pres_context: RawGeckoPresContextBorrowed) {
     let mut data = PerDocumentStyleData::from_ffi(raw_data).borrow_mut();
     data.default_computed_values = ComputedValues::default_values(pres_context);
+    // FIXME(bz): We need to update our Stylist's Device's computed values, but how?
 }
 
 #[no_mangle]

tests/unit/style/parsing/image.rs

@@ -8,6 +8,7 @@ use euclid::size::Size2D;
 use media_queries::CSSErrorReporterTest;
 use std::f32::consts::PI;
 use style::parser::ParserContext;
+use style::properties::ComputedValues;
 use style::stylesheets::Origin;
 use style::values::computed;
 use style::values::computed::{Angle, Context, ToComputedValue};
@@ -43,7 +44,14 @@ fn test_linear_gradient() {
     // Note that Angle(PI) is correct for top-to-bottom rendering, whereas Angle(0) would render bottom-to-top.
     // ref: https://developer.mozilla.org/en-US/docs/Web/CSS/angle
     let container = Size2D::new(Au::default(), Au::default());
-    let specified_context = Context::initial(container, true);
+    let initial_style = ComputedValues::initial_values();
+    let specified_context = Context {
+        is_root_element: true,
+        viewport_size: container,
+        inherited_style: initial_style,
+        style: initial_style.clone(),
+        font_metrics_provider: None,
+    };
     assert_eq!(specified::AngleOrCorner::None.to_computed_value(&specified_context),
                computed::AngleOrCorner::Angle(Angle(PI)));
 }