--- a/servo/components/atoms/static_atoms.txt
+++ b/servo/components/atoms/static_atoms.txt
@@ -65,8 +65,11 @@ controllerchange
 fetch
 characteristicvaluechanged
 fullscreenchange
 fullscreenerror
 gattserverdisconnected
 onchange
 
 reftest-wait
+
+screen
+print

--- a/servo/components/layout_thread/lib.rs
+++ b/servo/components/layout_thread/lib.rs
@@ -476,17 +476,17 @@ impl LayoutThread {
            webrender_api_sender: webrender_api::RenderApiSender,
            webrender_document: webrender_api::DocumentId,
            layout_threads: usize,
            paint_time_metrics: PaintTimeMetrics)
            -> LayoutThread {
         // The device pixel ratio is incorrect (it does not have the hidpi value),
         // but it will be set correctly when the initial reflow takes place.
         let device = Device::new(
-            MediaType::Screen,
+            MediaType::screen(),
             opts::get().initial_window_size.to_f32() * ScaleFactor::new(1.0),
             ScaleFactor::new(opts::get().device_pixels_per_px.unwrap_or(1.0)));
 
         let configuration =
             rayon::Configuration::new().num_threads(layout_threads);
         let parallel_traversal = if layout_threads > 1 {
             Some(rayon::ThreadPool::new(configuration).expect("ThreadPool creation failed"))
         } else {
@@ -1151,17 +1151,17 @@ impl LayoutThread {
         let current_screen_size = Size2D::new(Au::from_f32_px(initial_viewport.width),
                                               Au::from_f32_px(initial_viewport.height));
 
         // Calculate the actual viewport as per DEVICE-ADAPT § 6
 
         let document_shared_lock = document.style_shared_lock();
         self.document_shared_lock = Some(document_shared_lock.clone());
         let author_guard = document_shared_lock.read();
-        let device = Device::new(MediaType::Screen, initial_viewport, device_pixel_ratio);
+        let device = Device::new(MediaType::screen(), initial_viewport, device_pixel_ratio);
         self.stylist.set_device(device, &author_guard, &data.document_stylesheets);
 
         self.viewport_size =
             self.stylist.viewport_constraints().map_or(current_screen_size, |constraints| {
                 debug!("Viewport constraints: {:?}", constraints);
 
                 // other rules are evaluated against the actual viewport
                 Size2D::new(Au::from_f32_px(constraints.size.width),

--- a/servo/components/script/dom/mediaquerylist.rs
+++ b/servo/components/script/dom/mediaquerylist.rs
@@ -72,17 +72,17 @@ impl MediaQueryList {
         self.last_match_state.set(Some(matches));
         result
     }
 
     pub fn evaluate(&self) -> bool {
         if let Some(window_size) = self.document.window().window_size() {
             let viewport_size = window_size.initial_viewport;
             let device_pixel_ratio = window_size.device_pixel_ratio;
-            let device = Device::new(MediaType::Screen, viewport_size, device_pixel_ratio);
+            let device = Device::new(MediaType::screen(), viewport_size, device_pixel_ratio);
             self.media_query_list.evaluate(&device, self.document.quirks_mode())
         } else {
             false
         }
     }
 }
 
 impl MediaQueryListMethods for MediaQueryList {

--- a/servo/components/style/media_queries.rs
+++ b/servo/components/style/media_queries.rs
@@ -161,16 +161,26 @@ impl MediaQueryType {
 }
 
 /// https://drafts.csswg.org/mediaqueries/#media-types
 #[derive(PartialEq, Eq, Clone, Debug)]
 #[cfg_attr(feature = "servo", derive(HeapSizeOf))]
 pub struct MediaType(pub CustomIdent);
 
 impl MediaType {
+    /// The `screen` media type.
+    pub fn screen() -> Self {
+        MediaType(CustomIdent(atom!("screen")))
+    }
+
+    /// The `print` media type.
+    pub fn print() -> Self {
+        MediaType(CustomIdent(atom!("print")))
+    }
+
     fn parse(name: &str) -> Result<Self, ()> {
         // From https://drafts.csswg.org/mediaqueries/#mq-syntax:
         //
         //   The <media-type> production does not include the keywords not, or, and, and only.
         //
         // Here we also perform the to-ascii-lowercase part of the serialization
         // algorithm: https://drafts.csswg.org/cssom/#serializing-media-queries
         match_ignore_ascii_case! { name,

--- a/servo/tests/unit/style/media_queries.rs
+++ b/servo/tests/unit/style/media_queries.rs
@@ -10,17 +10,17 @@ use servo_url::ServoUrl;
 use std::borrow::ToOwned;
 use style::Atom;
 use style::context::QuirksMode;
 use style::error_reporting::{ParseErrorReporter, ContextualParseError};
 use style::media_queries::*;
 use style::servo::media_queries::*;
 use style::shared_lock::SharedRwLock;
 use style::stylesheets::{AllRules, Stylesheet, StylesheetInDocument, Origin, CssRule};
-use style::values::specified;
+use style::values::{CustomIdent, specified};
 use style_traits::ToCss;
 
 pub struct CSSErrorReporterTest;
 
 impl ParseErrorReporter for CSSErrorReporterTest {
     fn report_error<'a>(&self,
                         _input: &mut Parser,
                         _position: SourcePosition,
@@ -35,17 +35,17 @@ fn test_media_rule<F>(css: &str, callbac
 {
     let url = ServoUrl::parse("http://localhost").unwrap();
     let css_str = css.to_owned();
     let lock = SharedRwLock::new();
     let media_list = Arc::new(lock.wrap(MediaList::empty()));
     let stylesheet = Stylesheet::from_str(
         css, url, Origin::Author, media_list, lock,
         None, &CSSErrorReporterTest, QuirksMode::NoQuirks, 0u64);
-    let dummy = Device::new(MediaType::Screen, TypedSize2D::new(200.0, 100.0), ScaleFactor::new(1.0));
+    let dummy = Device::new(MediaType::screen(), TypedSize2D::new(200.0, 100.0), ScaleFactor::new(1.0));
     let mut rule_count = 0;
     let guard = stylesheet.shared_lock.read();
     for rule in stylesheet.iter_rules::<AllRules>(&dummy, &guard) {
         if let CssRule::Media(ref lock) = *rule {
             rule_count += 1;
             callback(&lock.read_with(&guard).media_queries.read_with(&guard), css);
         }
     }
@@ -72,87 +72,90 @@ fn test_mq_empty() {
 }
 
 #[test]
 fn test_mq_screen() {
     test_media_rule("@media screen { }", |list, css| {
         assert!(list.media_queries.len() == 1, css.to_owned());
         let q = &list.media_queries[0];
         assert!(q.qualifier == None, css.to_owned());
-        assert!(q.media_type == MediaQueryType::Known(MediaType::Screen), css.to_owned());
+        assert!(q.media_type == MediaQueryType::Concrete(MediaType::screen()), css.to_owned());
         assert!(q.expressions.len() == 0, css.to_owned());
     });
 
     test_media_rule("@media only screen { }", |list, css| {
         assert!(list.media_queries.len() == 1, css.to_owned());
         let q = &list.media_queries[0];
         assert!(q.qualifier == Some(Qualifier::Only), css.to_owned());
-        assert!(q.media_type == MediaQueryType::Known(MediaType::Screen), css.to_owned());
+        assert!(q.media_type == MediaQueryType::Concrete(MediaType::screen()), css.to_owned());
         assert!(q.expressions.len() == 0, css.to_owned());
     });
 
     test_media_rule("@media not screen { }", |list, css| {
         assert!(list.media_queries.len() == 1, css.to_owned());
         let q = &list.media_queries[0];
         assert!(q.qualifier == Some(Qualifier::Not), css.to_owned());
-        assert!(q.media_type == MediaQueryType::Known(MediaType::Screen), css.to_owned());
+        assert!(q.media_type == MediaQueryType::Concrete(MediaType::screen()), css.to_owned());
         assert!(q.expressions.len() == 0, css.to_owned());
     });
 }
 
 #[test]
 fn test_mq_print() {
     test_media_rule("@media print { }", |list, css| {
         assert!(list.media_queries.len() == 1, css.to_owned());
         let q = &list.media_queries[0];
         assert!(q.qualifier == None, css.to_owned());
-        assert!(q.media_type == MediaQueryType::Known(MediaType::Print), css.to_owned());
+        assert!(q.media_type == MediaQueryType::Concrete(MediaType::print()), css.to_owned());
         assert!(q.expressions.len() == 0, css.to_owned());
     });
 
     test_media_rule("@media only print { }", |list, css| {
         assert!(list.media_queries.len() == 1, css.to_owned());
         let q = &list.media_queries[0];
         assert!(q.qualifier == Some(Qualifier::Only), css.to_owned());
-        assert!(q.media_type == MediaQueryType::Known(MediaType::Print), css.to_owned());
+        assert!(q.media_type == MediaQueryType::Concrete(MediaType::print()), css.to_owned());
         assert!(q.expressions.len() == 0, css.to_owned());
     });
 
     test_media_rule("@media not print { }", |list, css| {
         assert!(list.media_queries.len() == 1, css.to_owned());
         let q = &list.media_queries[0];
         assert!(q.qualifier == Some(Qualifier::Not), css.to_owned());
-        assert!(q.media_type == MediaQueryType::Known(MediaType::Print), css.to_owned());
+        assert!(q.media_type == MediaQueryType::Concrete(MediaType::print()), css.to_owned());
         assert!(q.expressions.len() == 0, css.to_owned());
     });
 }
 
 #[test]
 fn test_mq_unknown() {
     test_media_rule("@media fridge { }", |list, css| {
         assert!(list.media_queries.len() == 1, css.to_owned());
         let q = &list.media_queries[0];
         assert!(q.qualifier == None, css.to_owned());
-        assert!(q.media_type == MediaQueryType::Unknown(Atom::from("fridge")), css.to_owned());
+        assert!(q.media_type == MediaQueryType::Concrete(
+            MediaType(CustomIdent(Atom::from("fridge")))), css.to_owned());
         assert!(q.expressions.len() == 0, css.to_owned());
     });
 
     test_media_rule("@media only glass { }", |list, css| {
         assert!(list.media_queries.len() == 1, css.to_owned());
         let q = &list.media_queries[0];
         assert!(q.qualifier == Some(Qualifier::Only), css.to_owned());
-        assert!(q.media_type == MediaQueryType::Unknown(Atom::from("glass")), css.to_owned());
+        assert!(q.media_type == MediaQueryType::Concrete(
+            MediaType(CustomIdent(Atom::from("glass")))), css.to_owned());
         assert!(q.expressions.len() == 0, css.to_owned());
     });
 
     test_media_rule("@media not wood { }", |list, css| {
         assert!(list.media_queries.len() == 1, css.to_owned());
         let q = &list.media_queries[0];
         assert!(q.qualifier == Some(Qualifier::Not), css.to_owned());
-        assert!(q.media_type == MediaQueryType::Unknown(Atom::from("wood")), css.to_owned());
+        assert!(q.media_type == MediaQueryType::Concrete(
+            MediaType(CustomIdent(Atom::from("wood")))), css.to_owned());
         assert!(q.expressions.len() == 0, css.to_owned());
     });
 }
 
 #[test]
 fn test_mq_all() {
     test_media_rule("@media all { }", |list, css| {
         assert!(list.media_queries.len() == 1, css.to_owned());
@@ -180,22 +183,22 @@ fn test_mq_all() {
 }
 
 #[test]
 fn test_mq_or() {
     test_media_rule("@media screen, print { }", |list, css| {
         assert!(list.media_queries.len() == 2, css.to_owned());
         let q0 = &list.media_queries[0];
         assert!(q0.qualifier == None, css.to_owned());
-        assert!(q0.media_type == MediaQueryType::Known(MediaType::Screen), css.to_owned());
+        assert!(q0.media_type == MediaQueryType::Concrete(MediaType::screen()), css.to_owned());
         assert!(q0.expressions.len() == 0, css.to_owned());
 
         let q1 = &list.media_queries[1];
         assert!(q1.qualifier == None, css.to_owned());
-        assert!(q1.media_type == MediaQueryType::Known(MediaType::Print), css.to_owned());
+        assert!(q1.media_type == MediaQueryType::Concrete(MediaType::print()), css.to_owned());
         assert!(q1.expressions.len() == 0, css.to_owned());
     });
 }
 
 #[test]
 fn test_mq_default_expressions() {
     test_media_rule("@media (min-width: 100px) { }", |list, css| {
         assert!(list.media_queries.len() == 1, css.to_owned());
@@ -223,53 +226,54 @@ fn test_mq_default_expressions() {
 }
 
 #[test]
 fn test_mq_expressions() {
     test_media_rule("@media screen and (min-width: 100px) { }", |list, css| {
         assert!(list.media_queries.len() == 1, css.to_owned());
         let q = &list.media_queries[0];
         assert!(q.qualifier == None, css.to_owned());
-        assert!(q.media_type == MediaQueryType::Known(MediaType::Screen), css.to_owned());
+        assert!(q.media_type == MediaQueryType::Concrete(MediaType::screen()), css.to_owned());
         assert!(q.expressions.len() == 1, css.to_owned());
         match *q.expressions[0].kind_for_testing() {
             ExpressionKind::Width(Range::Min(ref w)) => assert!(*w == specified::Length::from_px(100.)),
             _ => panic!("wrong expression type"),
         }
     });
 
     test_media_rule("@media print and (max-width: 43px) { }", |list, css| {
         assert!(list.media_queries.len() == 1, css.to_owned());
         let q = &list.media_queries[0];
         assert!(q.qualifier == None, css.to_owned());
-        assert!(q.media_type == MediaQueryType::Known(MediaType::Print), css.to_owned());
+        assert!(q.media_type == MediaQueryType::Concrete(MediaType::print()), css.to_owned());
         assert!(q.expressions.len() == 1, css.to_owned());
         match *q.expressions[0].kind_for_testing() {
             ExpressionKind::Width(Range::Max(ref w)) => assert!(*w == specified::Length::from_px(43.)),
             _ => panic!("wrong expression type"),
         }
     });
 
     test_media_rule("@media print and (width: 43px) { }", |list, css| {
         assert!(list.media_queries.len() == 1, css.to_owned());
         let q = &list.media_queries[0];
         assert!(q.qualifier == None, css.to_owned());
-        assert!(q.media_type == MediaQueryType::Known(MediaType::Print), css.to_owned());
+        assert!(q.media_type == MediaQueryType::Concrete(MediaType::print()), css.to_owned());
         assert!(q.expressions.len() == 1, css.to_owned());
         match *q.expressions[0].kind_for_testing() {
             ExpressionKind::Width(Range::Eq(ref w)) => assert!(*w == specified::Length::from_px(43.)),
             _ => panic!("wrong expression type"),
         }
     });
 
     test_media_rule("@media fridge and (max-width: 52px) { }", |list, css| {
         assert!(list.media_queries.len() == 1, css.to_owned());
         let q = &list.media_queries[0];
         assert!(q.qualifier == None, css.to_owned());
-        assert!(q.media_type == MediaQueryType::Unknown(Atom::from("fridge")), css.to_owned());
+        assert!(q.media_type == MediaQueryType::Concrete(
+            MediaType(CustomIdent(Atom::from("fridge")))), css.to_owned());
         assert!(q.expressions.len() == 1, css.to_owned());
         match *q.expressions[0].kind_for_testing() {
             ExpressionKind::Width(Range::Max(ref w)) => assert!(*w == specified::Length::from_px(52.)),
             _ => panic!("wrong expression type"),
         }
     });
 }
 
@@ -300,17 +304,17 @@ fn test_mq_multiple_expressions() {
             _ => panic!("wrong expression type"),
         }
     });
 
     test_media_rule("@media not screen and (min-width: 100px) and (max-width: 200px) { }", |list, css| {
         assert!(list.media_queries.len() == 1, css.to_owned());
         let q = &list.media_queries[0];
         assert!(q.qualifier == Some(Qualifier::Not), css.to_owned());
-        assert!(q.media_type == MediaQueryType::Known(MediaType::Screen), css.to_owned());
+        assert!(q.media_type == MediaQueryType::Concrete(MediaType::screen()), css.to_owned());
         assert!(q.expressions.len() == 2, css.to_owned());
         match *q.expressions[0].kind_for_testing() {
             ExpressionKind::Width(Range::Min(ref w)) => assert!(*w == specified::Length::from_px(100.)),
             _ => panic!("wrong expression type"),
         }
         match *q.expressions[1].kind_for_testing() {
             ExpressionKind::Width(Range::Max(ref w)) => assert!(*w == specified::Length::from_px(200.)),
             _ => panic!("wrong expression type"),
@@ -338,33 +342,33 @@ fn test_mq_malformed_expressions() {
         "@media , {}",
     ] {
         test_media_rule(rule, check_malformed_expr);
     }
 }
 
 #[test]
 fn test_matching_simple() {
-    let device = Device::new(MediaType::Screen, TypedSize2D::new(200.0, 100.0), ScaleFactor::new(1.0));
+    let device = Device::new(MediaType::screen(), TypedSize2D::new(200.0, 100.0), ScaleFactor::new(1.0));
 
     media_query_test(&device, "@media not all { a { color: red; } }", 0);
     media_query_test(&device, "@media not screen { a { color: red; } }", 0);
     media_query_test(&device, "@media not print { a { color: red; } }", 1);
 
     media_query_test(&device, "@media unknown { a { color: red; } }", 0);
     media_query_test(&device, "@media not unknown { a { color: red; } }", 1);
 
     media_query_test(&device, "@media { a { color: red; } }", 1);
     media_query_test(&device, "@media screen { a { color: red; } }", 1);
     media_query_test(&device, "@media print { a { color: red; } }", 0);
 }
 
 #[test]
 fn test_matching_width() {
-    let device = Device::new(MediaType::Screen, TypedSize2D::new(200.0, 100.0), ScaleFactor::new(1.0));
+    let device = Device::new(MediaType::screen(), TypedSize2D::new(200.0, 100.0), ScaleFactor::new(1.0));
 
     media_query_test(&device, "@media { a { color: red; } }", 1);
 
     media_query_test(&device, "@media (min-width: 50px) { a { color: red; } }", 1);
     media_query_test(&device, "@media (min-width: 150px) { a { color: red; } }", 1);
     media_query_test(&device, "@media (min-width: 300px) { a { color: red; } }", 0);
 
     media_query_test(&device, "@media screen and (min-width: 50px) { a { color: red; } }", 1);
@@ -395,14 +399,14 @@ fn test_matching_width() {
     media_query_test(
         &device, "@media not screen and (min-width: 16em) and (max-width: 19.75em) { a { color: red; } }", 1);
     media_query_test(
         &device, "@media not screen and (min-width: 3em) and (max-width: 250px) { a { color: red; } }", 0);
 }
 
 #[test]
 fn test_matching_invalid() {
-    let device = Device::new(MediaType::Screen, TypedSize2D::new(200.0, 100.0), ScaleFactor::new(1.0));
+    let device = Device::new(MediaType::screen(), TypedSize2D::new(200.0, 100.0), ScaleFactor::new(1.0));
 
     media_query_test(&device, "@media fridge { a { color: red; } }", 0);
     media_query_test(&device, "@media screen and (height: 100px) { a { color: red; } }", 0);
     media_query_test(&device, "@media not print and (width: 100) { a { color: red; } }", 0);
 }

--- a/servo/tests/unit/style/stylist.rs
+++ b/servo/tests/unit/style/stylist.rs
@@ -218,27 +218,27 @@ fn test_insert() {
     selector_map.insert(rules_list[1][0].clone(), QuirksMode::NoQuirks);
     assert_eq!(1, selector_map.id_hash.get(&Atom::from("top"), QuirksMode::NoQuirks).unwrap()[0].source_order);
     selector_map.insert(rules_list[0][0].clone(), QuirksMode::NoQuirks);
     assert_eq!(0, selector_map.class_hash.get(&Atom::from("intro"), QuirksMode::NoQuirks).unwrap()[0].source_order);
     assert!(selector_map.class_hash.get(&Atom::from("foo"), QuirksMode::NoQuirks).is_none());
 }
 
 fn mock_stylist() -> Stylist {
-    let device = Device::new(MediaType::Screen, TypedSize2D::new(0f32, 0f32), ScaleFactor::new(1.0));
+    let device = Device::new(MediaType::screen(), TypedSize2D::new(0f32, 0f32), ScaleFactor::new(1.0));
     Stylist::new(device, QuirksMode::NoQuirks)
 }
 
 #[test]
 fn test_stylist_device_accessors() {
     thread_state::initialize(thread_state::LAYOUT);
     let stylist = mock_stylist();
-    assert_eq!(stylist.device().media_type(), MediaType::Screen);
+    assert_eq!(stylist.device().media_type(), MediaType::screen());
     let mut stylist_mut = mock_stylist();
-    assert_eq!(stylist_mut.device_mut().media_type(), MediaType::Screen);
+    assert_eq!(stylist_mut.device_mut().media_type(), MediaType::screen());
 }
 
 #[test]
 fn test_stylist_rule_tree_accessors() {
     thread_state::initialize(thread_state::LAYOUT);
     let stylist = mock_stylist();
     stylist.rule_tree();
     stylist.rule_tree().root();

--- a/servo/tests/unit/style/viewport.rs
+++ b/servo/tests/unit/style/viewport.rs
@@ -92,17 +92,17 @@ macro_rules! viewport_length {
     };
     ($value:expr, vw) => {
         ViewportLength::Specified(LengthOrPercentageOrAuto::Length(ViewportPercentage(Vw($value))))
     }
 }
 
 #[test]
 fn empty_viewport_rule() {
-    let device = Device::new(MediaType::Screen, TypedSize2D::new(800., 600.), ScaleFactor::new(1.0));
+    let device = Device::new(MediaType::screen(), TypedSize2D::new(800., 600.), ScaleFactor::new(1.0));
 
     test_viewport_rule("@viewport {}", &device, |declarations, css| {
         println!("{}", css);
         assert_decl_len!(declarations == 0);
     });
 }
 
 macro_rules! assert_decl_eq {
@@ -115,17 +115,17 @@ macro_rules! assert_decl_eq {
         assert_eq!($d.origin, Origin::$origin);
         assert_eq!($d.descriptor, ViewportDescriptor::$expected($value));
         assert!($d.important == true, "descriptor should be !important");
     }};
 }
 
 #[test]
 fn simple_viewport_rules() {
-    let device = Device::new(MediaType::Screen, TypedSize2D::new(800., 600.), ScaleFactor::new(1.0));
+    let device = Device::new(MediaType::screen(), TypedSize2D::new(800., 600.), ScaleFactor::new(1.0));
 
     test_viewport_rule("@viewport { width: auto; height: auto;\
                                     zoom: auto; min-zoom: 0; max-zoom: 200%;\
                                     user-zoom: zoom; orientation: auto; }",
                        &device, |declarations, css| {
         println!("{}", css);
         assert_decl_len!(declarations == 9);
         assert_decl_eq!(&declarations[0], Author, MinWidth: ViewportLength::Specified(Auto));
@@ -187,17 +187,17 @@ fn simple_meta_viewport_contents() {
         assert_decl_eq!(&declarations[1], Author, MaxWidth: viewport_length!(480., px));
         assert_decl_eq!(&declarations[2], Author, Zoom: Zoom::Number(2.));
         assert_decl_eq!(&declarations[3], Author, UserZoom: UserZoom::Zoom);
     });
 }
 
 #[test]
 fn cascading_within_viewport_rule() {
-    let device = Device::new(MediaType::Screen, TypedSize2D::new(800., 600.), ScaleFactor::new(1.0));
+    let device = Device::new(MediaType::screen(), TypedSize2D::new(800., 600.), ScaleFactor::new(1.0));
 
     // normal order of appearance
     test_viewport_rule("@viewport { min-width: 200px; min-width: auto; }",
                        &device, |declarations, css| {
         println!("{}", css);
         assert_decl_len!(declarations == 1);
         assert_decl_eq!(&declarations[0], Author, MinWidth: ViewportLength::Specified(Auto));
     });
@@ -253,17 +253,17 @@ fn cascading_within_viewport_rule() {
         assert_decl_eq!(&declarations[0], Author, MinWidth: ViewportLength::Specified(Auto), !important);
         assert_decl_eq!(&declarations[1], Author, MaxWidth: ViewportLength::Specified(Auto), !important);
     });
 }
 
 #[test]
 fn multiple_stylesheets_cascading() {
     PREFS.set("layout.viewport.enabled", PrefValue::Boolean(true));
-    let device = Device::new(MediaType::Screen, TypedSize2D::new(800., 600.), ScaleFactor::new(1.0));
+    let device = Device::new(MediaType::screen(), TypedSize2D::new(800., 600.), ScaleFactor::new(1.0));
     let error_reporter = CSSErrorReporterTest;
     let shared_lock = SharedRwLock::new();
     let stylesheets = vec![
         stylesheet!("@viewport { min-width: 100px; min-height: 100px; zoom: 1; }",
                     UserAgent, error_reporter, shared_lock.clone()),
         stylesheet!("@viewport { min-width: 200px; min-height: 200px; }",
                     User, error_reporter, shared_lock.clone()),
         stylesheet!("@viewport { min-width: 300px; }",
@@ -309,17 +309,17 @@ fn constrain_viewport() {
 
     macro_rules! from_css {
         ($css:expr) => {
             &ViewportRule::parse(&context, &mut Parser::new(&mut $css)).unwrap()
         }
     }
 
     let initial_viewport = TypedSize2D::new(800., 600.);
-    let device = Device::new(MediaType::Screen, initial_viewport, ScaleFactor::new(1.0));
+    let device = Device::new(MediaType::screen(), initial_viewport, ScaleFactor::new(1.0));
     let mut input = ParserInput::new("");
     assert_eq!(ViewportConstraints::maybe_new(&device, from_css!(input), QuirksMode::NoQuirks), None);
 
     let mut input = ParserInput::new("width: 320px auto");
     assert_eq!(ViewportConstraints::maybe_new(&device, from_css!(input), QuirksMode::NoQuirks),
                Some(ViewportConstraints {
                    size: initial_viewport,
 
@@ -358,17 +358,17 @@ fn constrain_viewport() {
                    min_zoom: None,
                    max_zoom: None,
 
                    user_zoom: UserZoom::Zoom,
                    orientation: Orientation::Auto
                }));
 
     let initial_viewport = TypedSize2D::new(200., 150.);
-    let device = Device::new(MediaType::Screen, initial_viewport, ScaleFactor::new(1.0));
+    let device = Device::new(MediaType::screen(), initial_viewport, ScaleFactor::new(1.0));
     let mut input = ParserInput::new("width: 320px auto");
     assert_eq!(ViewportConstraints::maybe_new(&device, from_css!(input), QuirksMode::NoQuirks),
                Some(ViewportConstraints {
                    size: TypedSize2D::new(320., 240.),
 
                    initial_zoom: PinchZoomFactor::new(1.),
                    min_zoom: None,
                    max_zoom: None,