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.