diff --git a/components/layout_thread/lib.rs b/components/layout_thread/lib.rs
index 20ef9ff6cb4..342f8195cb6 100644
--- a/components/layout_thread/lib.rs
+++ b/components/layout_thread/lib.rs
@@ -1542,6 +1542,7 @@ fn get_ua_stylesheets() -> Result<UserAgentStylesheets, &'static str> {
             None,
             Origin::UserAgent,
             Default::default(),
+            None,
             Box::new(StdoutErrorReporter),
             ParserContextExtraData::default()))
     }
@@ -1555,7 +1556,8 @@ fn get_ua_stylesheets() -> Result<UserAgentStylesheets, &'static str> {
     for &(ref contents, ref url) in &opts::get().user_stylesheets {
         user_or_user_agent_stylesheets.push(Stylesheet::from_bytes(
             &contents, url.clone(), None, None, Origin::User, Default::default(),
-            Box::new(StdoutErrorReporter), ParserContextExtraData::default()));
+            None, Box::new(StdoutErrorReporter),
+            ParserContextExtraData::default()));
     }
 
     let quirks_mode_stylesheet = try!(parse_ua_stylesheet("quirks-mode.css"));
diff --git a/components/script/dom/bindings/trace.rs b/components/script/dom/bindings/trace.rs
index ad8dc6b935e..3365c106bd9 100644
--- a/components/script/dom/bindings/trace.rs
+++ b/components/script/dom/bindings/trace.rs
@@ -98,7 +98,7 @@ use style::keyframes::Keyframe;
 use style::media_queries::MediaList;
 use style::properties::PropertyDeclarationBlock;
 use style::selector_parser::{PseudoElement, Snapshot};
-use style::stylesheets::{CssRules, KeyframesRule, MediaRule, NamespaceRule, StyleRule};
+use style::stylesheets::{CssRules, KeyframesRule, MediaRule, NamespaceRule, StyleRule, ImportRule};
 use style::values::specified::Length;
 use style::viewport::ViewportRule;
 use time::Duration;
@@ -525,6 +525,12 @@ unsafe impl JSTraceable for RwLock<KeyframesRule> {
     }
 }
 
+unsafe impl JSTraceable for RwLock<ImportRule> {
+    unsafe fn trace(&self, _trc: *mut JSTracer) {
+        // Do nothing.
+    }
+}
+
 unsafe impl JSTraceable for RwLock<MediaRule> {
     unsafe fn trace(&self, _trc: *mut JSTracer) {
         // Do nothing.
diff --git a/components/script/dom/create.rs b/components/script/dom/create.rs
index cb591e74c55..7c9a9eeea9c 100644
--- a/components/script/dom/create.rs
+++ b/components/script/dom/create.rs
@@ -244,7 +244,7 @@ fn create_html_element(name: QualName,
         local_name!("span")       => make!(HTMLSpanElement),
         local_name!("strike")     => make!(HTMLElement),
         local_name!("strong")     => make!(HTMLElement),
-        local_name!("style")      => make!(HTMLStyleElement),
+        local_name!("style")      => make!(HTMLStyleElement, creator),
         local_name!("sub")        => make!(HTMLElement),
         local_name!("summary")    => make!(HTMLElement),
         local_name!("sup")        => make!(HTMLElement),
diff --git a/components/script/dom/cssimportrule.rs b/components/script/dom/cssimportrule.rs
new file mode 100644
index 00000000000..582a6f597f9
--- /dev/null
+++ b/components/script/dom/cssimportrule.rs
@@ -0,0 +1,53 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * 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/. */
+
+use dom::bindings::codegen::Bindings::CSSImportRuleBinding;
+use dom::bindings::js::Root;
+use dom::bindings::reflector::reflect_dom_object;
+use dom::bindings::str::DOMString;
+use dom::cssrule::{CSSRule, SpecificCSSRule};
+use dom::cssstylesheet::CSSStyleSheet;
+use dom::window::Window;
+use parking_lot::RwLock;
+use std::sync::Arc;
+use style::stylesheets::ImportRule;
+use style_traits::ToCss;
+
+#[dom_struct]
+pub struct CSSImportRule {
+    cssrule: CSSRule,
+    #[ignore_heap_size_of = "Arc"]
+    import_rule: Arc<RwLock<ImportRule>>,
+}
+
+impl CSSImportRule {
+    fn new_inherited(parent_stylesheet: &CSSStyleSheet,
+                     import_rule: Arc<RwLock<ImportRule>>)
+                     -> Self {
+        CSSImportRule {
+            cssrule: CSSRule::new_inherited(parent_stylesheet),
+            import_rule: import_rule,
+        }
+    }
+
+    #[allow(unrooted_must_root)]
+    pub fn new(window: &Window,
+               parent_stylesheet: &CSSStyleSheet,
+               import_rule: Arc<RwLock<ImportRule>>) -> Root<Self> {
+        reflect_dom_object(box Self::new_inherited(parent_stylesheet, import_rule),
+                           window,
+                           CSSImportRuleBinding::Wrap)
+    }
+}
+
+impl SpecificCSSRule for CSSImportRule {
+    fn ty(&self) -> u16 {
+        use dom::bindings::codegen::Bindings::CSSRuleBinding::CSSRuleConstants;
+        CSSRuleConstants::IMPORT_RULE
+    }
+
+    fn get_css(&self) -> DOMString {
+        self.import_rule.read().to_css_string().into()
+    }
+}
diff --git a/components/script/dom/cssrule.rs b/components/script/dom/cssrule.rs
index 603354c8621..27b439f9dc4 100644
--- a/components/script/dom/cssrule.rs
+++ b/components/script/dom/cssrule.rs
@@ -9,6 +9,7 @@ use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
 use dom::cssfontfacerule::CSSFontFaceRule;
+use dom::cssimportrule::CSSImportRule;
 use dom::csskeyframerule::CSSKeyframeRule;
 use dom::csskeyframesrule::CSSKeyframesRule;
 use dom::cssmediarule::CSSMediaRule;
@@ -64,6 +65,8 @@ impl CSSRule {
             rule as &SpecificCSSRule
         } else if let Some(rule) = self.downcast::<CSSKeyframeRule>() {
             rule as &SpecificCSSRule
+        } else if let Some(rule) = self.downcast::<CSSImportRule>() {
+            rule as &SpecificCSSRule
         } else {
             unreachable!()
         }
@@ -75,6 +78,7 @@ impl CSSRule {
                         rule: StyleCssRule) -> Root<CSSRule> {
         // be sure to update the match in as_specific when this is updated
         match rule {
+            StyleCssRule::Import(s) => Root::upcast(CSSImportRule::new(window, parent_stylesheet, s)),
             StyleCssRule::Style(s) => Root::upcast(CSSStyleRule::new(window, parent_stylesheet, s)),
             StyleCssRule::FontFace(s) => Root::upcast(CSSFontFaceRule::new(window, parent_stylesheet, s)),
             StyleCssRule::Keyframes(s) => Root::upcast(CSSKeyframesRule::new(window, parent_stylesheet, s)),
diff --git a/components/script/dom/element.rs b/components/script/dom/element.rs
index 66021ce6104..21dfde99f22 100644
--- a/components/script/dom/element.rs
+++ b/components/script/dom/element.rs
@@ -51,9 +51,11 @@ use dom::htmlimageelement::{HTMLImageElement, LayoutHTMLImageElementHelpers};
 use dom::htmlinputelement::{HTMLInputElement, LayoutHTMLInputElementHelpers};
 use dom::htmllabelelement::HTMLLabelElement;
 use dom::htmllegendelement::HTMLLegendElement;
+use dom::htmllinkelement::HTMLLinkElement;
 use dom::htmlobjectelement::HTMLObjectElement;
 use dom::htmloptgroupelement::HTMLOptGroupElement;
 use dom::htmlselectelement::HTMLSelectElement;
+use dom::htmlstyleelement::HTMLStyleElement;
 use dom::htmltablecellelement::{HTMLTableCellElement, HTMLTableCellElementLayoutHelpers};
 use dom::htmltableelement::{HTMLTableElement, HTMLTableElementLayoutHelpers};
 use dom::htmltablerowelement::{HTMLTableRowElement, HTMLTableRowElementLayoutHelpers};
@@ -109,6 +111,7 @@ use style::sink::Push;
 use style::stylist::ApplicableDeclarationBlock;
 use style::values::CSSFloat;
 use style::values::specified::{self, CSSColor, CSSRGBA, LengthOrPercentage};
+use stylesheet_loader::StylesheetOwner;
 
 // TODO: Update focus state when the top-level browsing context gains or loses system focus,
 // and when the element enters or leaves a browsing context container.
@@ -2407,6 +2410,18 @@ impl Element {
         })
     }
 
+    pub fn as_stylesheet_owner(&self) -> Option<&StylesheetOwner> {
+        if let Some(s) = self.downcast::<HTMLStyleElement>() {
+            return Some(s as &StylesheetOwner)
+        }
+
+        if let Some(l) = self.downcast::<HTMLLinkElement>() {
+            return Some(l as &StylesheetOwner)
+        }
+
+        None
+    }
+
     // https://html.spec.whatwg.org/multipage/#category-submit
     pub fn as_maybe_validatable(&self) -> Option<&Validatable> {
         let element = match self.upcast::<Node>().type_id() {
diff --git a/components/script/dom/htmllinkelement.rs b/components/script/dom/htmllinkelement.rs
index 145b53b3ec7..cc66a822d92 100644
--- a/components/script/dom/htmllinkelement.rs
+++ b/components/script/dom/htmllinkelement.rs
@@ -3,52 +3,36 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use cssparser::Parser as CssParser;
-use document_loader::LoadType;
 use dom::attr::Attr;
 use dom::bindings::cell::DOMRefCell;
-use dom::bindings::codegen::Bindings::DOMTokenListBinding::DOMTokenListMethods;
+use dom::bindings::codegen::Bindings::DOMTokenListBinding::DOMTokenListBinding::DOMTokenListMethods;
 use dom::bindings::codegen::Bindings::HTMLLinkElementBinding;
 use dom::bindings::codegen::Bindings::HTMLLinkElementBinding::HTMLLinkElementMethods;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::{MutNullableJS, Root, RootedReference};
-use dom::bindings::refcounted::Trusted;
-use dom::bindings::reflector::DomObject;
 use dom::bindings::str::DOMString;
 use dom::cssstylesheet::CSSStyleSheet;
 use dom::document::Document;
 use dom::domtokenlist::DOMTokenList;
 use dom::element::{AttributeMutation, Element, ElementCreator};
-use dom::eventtarget::EventTarget;
 use dom::globalscope::GlobalScope;
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, document_from_node, window_from_node};
 use dom::stylesheet::StyleSheet as DOMStyleSheet;
 use dom::virtualmethods::VirtualMethods;
-use encoding::EncodingRef;
-use encoding::all::UTF_8;
 use html5ever_atoms::LocalName;
-use hyper::header::ContentType;
-use hyper::mime::{Mime, TopLevel, SubLevel};
-use hyper_serde::Serde;
-use ipc_channel::ipc;
-use ipc_channel::router::ROUTER;
-use net_traits::{FetchResponseListener, FetchMetadata, Metadata, NetworkError, ReferrerPolicy};
-use net_traits::request::{CredentialsMode, Destination, RequestInit, Type as RequestType};
-use network_listener::{NetworkListener, PreInvoke};
-use script_layout_interface::message::Msg;
+use net_traits::ReferrerPolicy;
 use script_traits::{MozBrowserEvent, ScriptMsg as ConstellationMsg};
-use servo_url::ServoUrl;
 use std::ascii::AsciiExt;
 use std::borrow::ToOwned;
 use std::cell::Cell;
 use std::default::Default;
-use std::mem;
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 use style::attr::AttrValue;
-use style::media_queries::{MediaList, parse_media_query_list};
-use style::parser::ParserContextExtraData;
+use style::media_queries::parse_media_query_list;
 use style::str::HTML_SPACE_CHARACTERS;
-use style::stylesheets::{Stylesheet, Origin};
+use style::stylesheets::Stylesheet;
+use stylesheet_loader::{StylesheetLoader, StylesheetContextSource, StylesheetOwner};
 
 unsafe_no_jsmanaged_fields!(Stylesheet);
 
@@ -62,6 +46,11 @@ pub struct HTMLLinkElement {
 
     /// https://html.spec.whatwg.org/multipage/#a-style-sheet-that-is-blocking-scripts
     parser_inserted: Cell<bool>,
+    /// The number of loads that this link element has triggered (could be more
+    /// than one because of imports) and have not yet finished.
+    pending_loads: Cell<u32>,
+    /// Whether any of the loads have failed.
+    any_failed_load: Cell<bool>,
 }
 
 impl HTMLLinkElement {
@@ -73,6 +62,8 @@ impl HTMLLinkElement {
             parser_inserted: Cell::new(creator == ElementCreator::ParserCreated),
             stylesheet: DOMRefCell::new(None),
             cssom_stylesheet: MutNullableJS::new(None),
+            pending_loads: Cell::new(0),
+            any_failed_load: Cell::new(false),
         }
     }
 
@@ -86,6 +77,16 @@ impl HTMLLinkElement {
                            HTMLLinkElementBinding::Wrap)
     }
 
+    pub fn parser_inserted(&self) -> bool {
+        self.parser_inserted.get()
+    }
+
+    pub fn set_stylesheet(&self, s: Arc<Stylesheet>) {
+        assert!(self.stylesheet.borrow().is_none());
+        *self.stylesheet.borrow_mut() = Some(s);
+    }
+
+
     pub fn get_stylesheet(&self) -> Option<Arc<Stylesheet>> {
         self.stylesheet.borrow().clone()
     }
@@ -231,8 +232,11 @@ impl HTMLLinkElement {
 
         // Step 2.
         let url = match document.base_url().join(href) {
-            Err(e) => return debug!("Parsing url {} failed: {}", href, e),
             Ok(url) => url,
+            Err(e) => {
+                debug!("Parsing url {} failed: {}", href, e);
+                return;
+            }
         };
 
         let element = self.upcast::<Element>();
@@ -246,50 +250,13 @@ impl HTMLLinkElement {
         let mut css_parser = CssParser::new(&mq_str);
         let media = parse_media_query_list(&mut css_parser);
 
-        // TODO: #8085 - Don't load external stylesheets if the node's mq doesn't match.
-        let elem = Trusted::new(self);
-
-        let context = Arc::new(Mutex::new(StylesheetContext {
-            elem: elem,
+        // TODO: #8085 - Don't load external stylesheets if the node's mq
+        // doesn't match.
+        let loader = StylesheetLoader::for_element(self.upcast());
+        loader.load(StylesheetContextSource::LinkElement {
+            url: url,
             media: Some(media),
-            data: vec!(),
-            metadata: None,
-            url: url.clone(),
-        }));
-
-        let (action_sender, action_receiver) = ipc::channel().unwrap();
-        let listener = NetworkListener {
-            context: context,
-            task_source: document.window().networking_task_source(),
-            wrapper: Some(document.window().get_runnable_wrapper())
-        };
-        ROUTER.add_route(action_receiver.to_opaque(), box move |message| {
-            listener.notify_fetch(message.to().unwrap());
         });
-
-        if self.parser_inserted.get() {
-            document.increment_script_blocking_stylesheet_count();
-        }
-
-        let referrer_policy = match self.RelList().Contains("noreferrer".into()) {
-            true => Some(ReferrerPolicy::NoReferrer),
-            false => document.get_referrer_policy(),
-        };
-
-        let request = RequestInit {
-            url: url.clone(),
-            type_: RequestType::Style,
-            destination: Destination::Style,
-            credentials_mode: CredentialsMode::Include,
-            use_url_credentials: true,
-            origin: document.url(),
-            pipeline_id: Some(self.global().pipeline_id()),
-            referrer_url: Some(document.url()),
-            referrer_policy: referrer_policy,
-            .. RequestInit::default()
-        };
-
-        document.fetch_async(LoadType::Stylesheet(url), request, action_sender);
     }
 
     fn handle_favicon_url(&self, rel: &str, href: &str, sizes: &Option<String>) {
@@ -310,92 +277,37 @@ impl HTMLLinkElement {
     }
 }
 
-/// The context required for asynchronously loading an external stylesheet.
-struct StylesheetContext {
-    /// The element that initiated the request.
-    elem: Trusted<HTMLLinkElement>,
-    media: Option<MediaList>,
-    /// The response body received to date.
-    data: Vec<u8>,
-    /// The response metadata received to date.
-    metadata: Option<Metadata>,
-    /// The initial URL requested.
-    url: ServoUrl,
-}
-
-impl PreInvoke for StylesheetContext {}
-
-impl FetchResponseListener for StylesheetContext {
-    fn process_request_body(&mut self) {}
-
-    fn process_request_eof(&mut self) {}
-
-    fn process_response(&mut self,
-                        metadata: Result<FetchMetadata, NetworkError>) {
-        self.metadata = metadata.ok().map(|m| {
-            match m {
-                FetchMetadata::Unfiltered(m) => m,
-                FetchMetadata::Filtered { unsafe_, .. } => unsafe_
-            }
-        });
-        if let Some(ref meta) = self.metadata {
-            if let Some(Serde(ContentType(Mime(TopLevel::Text, SubLevel::Css, _)))) = meta.content_type {
-            } else {
-                self.elem.root().upcast::<EventTarget>().fire_event(atom!("error"));
-            }
-        }
+impl StylesheetOwner for HTMLLinkElement {
+    fn increment_pending_loads_count(&self) {
+        self.pending_loads.set(self.pending_loads.get() + 1)
     }
 
-    fn process_response_chunk(&mut self, mut payload: Vec<u8>) {
-        self.data.append(&mut payload);
+    fn load_finished(&self, succeeded: bool) -> Option<bool> {
+        assert!(self.pending_loads.get() > 0, "What finished?");
+        if !succeeded {
+            self.any_failed_load.set(true);
+        }
+
+        self.pending_loads.set(self.pending_loads.get() - 1);
+        if self.pending_loads.get() != 0 {
+            return None;
+        }
+
+        let any_failed = self.any_failed_load.get();
+        self.any_failed_load.set(false);
+        Some(any_failed)
     }
 
-    fn process_response_eof(&mut self, status: Result<(), NetworkError>) {
-        let elem = self.elem.root();
-        let document = document_from_node(&*elem);
-        let mut successful = false;
+    fn parser_inserted(&self) -> bool {
+        self.parser_inserted.get()
+    }
 
-        if status.is_ok() {
-            let metadata = match self.metadata.take() {
-                Some(meta) => meta,
-                None => return,
-            };
-            let is_css = metadata.content_type.map_or(false, |Serde(ContentType(Mime(top, sub, _)))|
-                top == TopLevel::Text && sub == SubLevel::Css);
-
-            let data = if is_css { mem::replace(&mut self.data, vec!()) } else { vec!() };
-
-            // TODO: Get the actual value. http://dev.w3.org/csswg/css-syntax/#environment-encoding
-            let environment_encoding = UTF_8 as EncodingRef;
-            let protocol_encoding_label = metadata.charset.as_ref().map(|s| &**s);
-            let final_url = metadata.final_url;
-
-            let win = window_from_node(&*elem);
-
-            let sheet = Arc::new(Stylesheet::from_bytes(
-                &data, final_url, protocol_encoding_label, Some(environment_encoding),
-                Origin::Author, self.media.take().unwrap(), win.css_error_reporter(),
-                ParserContextExtraData::default()));
-
-            let win = window_from_node(&*elem);
-            win.layout_chan().send(Msg::AddStylesheet(sheet.clone())).unwrap();
-
-            *elem.stylesheet.borrow_mut() = Some(sheet);
-            document.invalidate_stylesheets();
-
-            // FIXME: Revisit once consensus is reached at: https://github.com/whatwg/html/issues/1142
-            successful = metadata.status.map_or(false, |(code, _)| code == 200);
+    fn referrer_policy(&self) -> Option<ReferrerPolicy> {
+        if self.RelList().Contains("noreferrer".into()) {
+            return Some(ReferrerPolicy::NoReferrer)
         }
 
-        if elem.parser_inserted.get() {
-            document.decrement_script_blocking_stylesheet_count();
-        }
-
-        document.finish_load(LoadType::Stylesheet(self.url.clone()));
-
-        let event = if successful { atom!("load") } else { atom!("error") };
-
-        elem.upcast::<EventTarget>().fire_event(event);
+        None
     }
 }
 
diff --git a/components/script/dom/htmlstyleelement.rs b/components/script/dom/htmlstyleelement.rs
index 8576a282052..2507f7bee35 100644
--- a/components/script/dom/htmlstyleelement.rs
+++ b/components/script/dom/htmlstyleelement.rs
@@ -12,17 +12,21 @@ use dom::bindings::js::{MutNullableJS, Root};
 use dom::bindings::str::DOMString;
 use dom::cssstylesheet::CSSStyleSheet;
 use dom::document::Document;
-use dom::element::Element;
+use dom::element::{Element, ElementCreator};
+use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::{ChildrenMutation, Node, document_from_node, window_from_node};
 use dom::stylesheet::StyleSheet as DOMStyleSheet;
 use dom::virtualmethods::VirtualMethods;
 use html5ever_atoms::LocalName;
+use net_traits::ReferrerPolicy;
 use script_layout_interface::message::Msg;
+use std::cell::Cell;
 use std::sync::Arc;
 use style::media_queries::parse_media_query_list;
 use style::parser::ParserContextExtraData;
 use style::stylesheets::{Stylesheet, Origin};
+use stylesheet_loader::{StylesheetLoader, StylesheetOwner};
 
 #[dom_struct]
 pub struct HTMLStyleElement {
@@ -30,24 +34,33 @@ pub struct HTMLStyleElement {
     #[ignore_heap_size_of = "Arc"]
     stylesheet: DOMRefCell<Option<Arc<Stylesheet>>>,
     cssom_stylesheet: MutNullableJS<CSSStyleSheet>,
+    /// https://html.spec.whatwg.org/multipage/#a-style-sheet-that-is-blocking-scripts
+    parser_inserted: Cell<bool>,
+    pending_loads: Cell<u32>,
+    any_failed_load: Cell<bool>,
 }
 
 impl HTMLStyleElement {
     fn new_inherited(local_name: LocalName,
                      prefix: Option<DOMString>,
-                     document: &Document) -> HTMLStyleElement {
+                     document: &Document,
+                     creator: ElementCreator) -> HTMLStyleElement {
         HTMLStyleElement {
             htmlelement: HTMLElement::new_inherited(local_name, prefix, document),
             stylesheet: DOMRefCell::new(None),
             cssom_stylesheet: MutNullableJS::new(None),
+            parser_inserted: Cell::new(creator == ElementCreator::ParserCreated),
+            pending_loads: Cell::new(0),
+            any_failed_load: Cell::new(false),
         }
     }
 
     #[allow(unrooted_must_root)]
     pub fn new(local_name: LocalName,
                prefix: Option<DOMString>,
-               document: &Document) -> Root<HTMLStyleElement> {
-        Node::reflect_node(box HTMLStyleElement::new_inherited(local_name, prefix, document),
+               document: &Document,
+               creator: ElementCreator) -> Root<HTMLStyleElement> {
+        Node::reflect_node(box HTMLStyleElement::new_inherited(local_name, prefix, document, creator),
                            document,
                            HTMLStyleElementBinding::Wrap)
     }
@@ -68,10 +81,19 @@ impl HTMLStyleElement {
 
         let data = node.GetTextContent().expect("Element.textContent must be a string");
         let mq = parse_media_query_list(&mut CssParser::new(&mq_str));
-        let sheet = Stylesheet::from_str(&data, url, Origin::Author, mq, win.css_error_reporter(),
+        let loader = StylesheetLoader::for_element(self.upcast());
+        let sheet = Stylesheet::from_str(&data, url, Origin::Author, mq,
+                                         Some(&loader),
+                                         win.css_error_reporter(),
                                          ParserContextExtraData::default());
+
         let sheet = Arc::new(sheet);
 
+        // No subresource loads were triggered, just fire the load event now.
+        if self.pending_loads.get() == 0 {
+            self.upcast::<EventTarget>().fire_event(atom!("load"));
+        }
+
         win.layout_chan().send(Msg::AddStylesheet(sheet.clone())).unwrap();
         *self.stylesheet.borrow_mut() = Some(sheet);
         let doc = document_from_node(self);
@@ -121,6 +143,37 @@ impl VirtualMethods for HTMLStyleElement {
     }
 }
 
+impl StylesheetOwner for HTMLStyleElement {
+    fn increment_pending_loads_count(&self) {
+        self.pending_loads.set(self.pending_loads.get() + 1)
+    }
+
+    fn load_finished(&self, succeeded: bool) -> Option<bool> {
+        assert!(self.pending_loads.get() > 0, "What finished?");
+        if !succeeded {
+            self.any_failed_load.set(true);
+        }
+
+        self.pending_loads.set(self.pending_loads.get() - 1);
+        if self.pending_loads.get() != 0 {
+            return None;
+        }
+
+        let any_failed = self.any_failed_load.get();
+        self.any_failed_load.set(false);
+        Some(any_failed)
+    }
+
+    fn parser_inserted(&self) -> bool {
+        self.parser_inserted.get()
+    }
+
+    fn referrer_policy(&self) -> Option<ReferrerPolicy> {
+        None
+    }
+}
+
+
 impl HTMLStyleElementMethods for HTMLStyleElement {
     // https://drafts.csswg.org/cssom/#dom-linkstyle-sheet
     fn GetSheet(&self) -> Option<Root<DOMStyleSheet>> {
diff --git a/components/script/dom/mod.rs b/components/script/dom/mod.rs
index 03847518408..b432b5a12e5 100644
--- a/components/script/dom/mod.rs
+++ b/components/script/dom/mod.rs
@@ -244,6 +244,7 @@ pub mod crypto;
 pub mod css;
 pub mod cssfontfacerule;
 pub mod cssgroupingrule;
+pub mod cssimportrule;
 pub mod csskeyframerule;
 pub mod csskeyframesrule;
 pub mod cssmediarule;
diff --git a/components/script/dom/webidls/CSSImportRule.webidl b/components/script/dom/webidls/CSSImportRule.webidl
new file mode 100644
index 00000000000..b8131a7bb87
--- /dev/null
+++ b/components/script/dom/webidls/CSSImportRule.webidl
@@ -0,0 +1,11 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * 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/. */
+
+// https://drafts.csswg.org/cssom/#cssimportrule
+[Exposed=Window]
+interface CSSImportRule : CSSRule {
+  // readonly attribute DOMString href;
+  // [SameObject, PutForwards=mediaText] readonly attribute MediaList media;
+  // [SameObject] readonly attribute CSSStyleSheet styleSheet;
+};
diff --git a/components/script/lib.rs b/components/script/lib.rs
index 1a751635ea5..508a2f13e9c 100644
--- a/components/script/lib.rs
+++ b/components/script/lib.rs
@@ -116,6 +116,7 @@ pub mod script_runtime;
 pub mod script_thread;
 mod serviceworker_manager;
 mod serviceworkerjob;
+mod stylesheet_loader;
 mod task_source;
 pub mod textinput;
 mod timers;
diff --git a/components/script/stylesheet_loader.rs b/components/script/stylesheet_loader.rs
new file mode 100644
index 00000000000..427593c8500
--- /dev/null
+++ b/components/script/stylesheet_loader.rs
@@ -0,0 +1,245 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * 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/. */
+
+use document_loader::LoadType;
+use dom::bindings::inheritance::Castable;
+use dom::bindings::refcounted::Trusted;
+use dom::bindings::reflector::DomObject;
+use dom::element::Element;
+use dom::eventtarget::EventTarget;
+use dom::htmlelement::HTMLElement;
+use dom::htmllinkelement::HTMLLinkElement;
+use dom::node::{document_from_node, window_from_node};
+use encoding::EncodingRef;
+use encoding::all::UTF_8;
+use hyper::header::ContentType;
+use hyper::mime::{Mime, TopLevel, SubLevel};
+use hyper_serde::Serde;
+use ipc_channel::ipc;
+use ipc_channel::router::ROUTER;
+use net_traits::{FetchResponseListener, FetchMetadata, Metadata, NetworkError, ReferrerPolicy};
+use net_traits::request::{CredentialsMode, Destination, RequestInit, Type as RequestType};
+use network_listener::{NetworkListener, PreInvoke};
+use parking_lot::RwLock;
+use script_layout_interface::message::Msg;
+use servo_url::ServoUrl;
+use std::mem;
+use std::sync::{Arc, Mutex};
+use style::media_queries::MediaList;
+use style::parser::ParserContextExtraData;
+use style::stylesheets::{ImportRule, Stylesheet, Origin};
+use style::stylesheets::StylesheetLoader as StyleStylesheetLoader;
+
+pub trait StylesheetOwner {
+    /// Returns whether this element was inserted by the parser (i.e., it should
+    /// trigger a document-load-blocking load).
+    fn parser_inserted(&self) -> bool;
+
+    /// Which referrer policy should loads triggered by this owner follow, or
+    /// `None` for the default.
+    fn referrer_policy(&self) -> Option<ReferrerPolicy>;
+
+    /// Notes that a new load is pending to finish.
+    fn increment_pending_loads_count(&self);
+
+    /// Returns None if there are still pending loads, or whether any load has
+    /// failed since the loads started.
+    fn load_finished(&self, successful: bool) -> Option<bool>;
+}
+
+pub enum StylesheetContextSource {
+    // NB: `media` is just an option so we avoid cloning it.
+    LinkElement { media: Option<MediaList>, url: ServoUrl },
+    Import(Arc<RwLock<ImportRule>>),
+}
+
+impl StylesheetContextSource {
+    fn url(&self) -> ServoUrl {
+        match *self {
+            StylesheetContextSource::LinkElement { ref url, .. } => url.clone(),
+            StylesheetContextSource::Import(ref import) => {
+                let import = import.read();
+                // Look at the parser in style::stylesheets, where we don't
+                // trigger a load if the url is invalid.
+                import.url.url()
+                    .expect("Invalid urls shouldn't enter the loader")
+                    .clone()
+            }
+        }
+    }
+}
+
+/// The context required for asynchronously loading an external stylesheet.
+pub struct StylesheetContext {
+    /// The element that initiated the request.
+    elem: Trusted<HTMLElement>,
+    source: StylesheetContextSource,
+    metadata: Option<Metadata>,
+    /// The response body received to date.
+    data: Vec<u8>,
+}
+
+impl PreInvoke for StylesheetContext {}
+
+impl FetchResponseListener for StylesheetContext {
+    fn process_request_body(&mut self) {}
+
+    fn process_request_eof(&mut self) {}
+
+    fn process_response(&mut self,
+                        metadata: Result<FetchMetadata, NetworkError>) {
+        self.metadata = metadata.ok().map(|m| {
+            match m {
+                FetchMetadata::Unfiltered(m) => m,
+                FetchMetadata::Filtered { unsafe_, .. } => unsafe_
+            }
+        });
+    }
+
+    fn process_response_chunk(&mut self, mut payload: Vec<u8>) {
+        self.data.append(&mut payload);
+    }
+
+    fn process_response_eof(&mut self, status: Result<(), NetworkError>) {
+        let elem = self.elem.root();
+        let document = document_from_node(&*elem);
+        let mut successful = false;
+
+        if status.is_ok() {
+            let metadata = match self.metadata.take() {
+                Some(meta) => meta,
+                None => return,
+            };
+            let is_css = metadata.content_type.map_or(false, |Serde(ContentType(Mime(top, sub, _)))|
+                top == TopLevel::Text && sub == SubLevel::Css);
+
+            let data = if is_css { mem::replace(&mut self.data, vec![]) } else { vec![] };
+
+            // TODO: Get the actual value. http://dev.w3.org/csswg/css-syntax/#environment-encoding
+            let environment_encoding = UTF_8 as EncodingRef;
+            let protocol_encoding_label = metadata.charset.as_ref().map(|s| &**s);
+            let final_url = metadata.final_url;
+
+            let win = window_from_node(&*elem);
+
+            let loader = StylesheetLoader::for_element(&elem);
+            match self.source {
+                StylesheetContextSource::LinkElement { ref mut media, .. } => {
+                    let sheet =
+                        Arc::new(Stylesheet::from_bytes(&data, final_url,
+                                                        protocol_encoding_label,
+                                                        Some(environment_encoding),
+                                                        Origin::Author,
+                                                        media.take().unwrap(),
+                                                        Some(&loader),
+                                                        win.css_error_reporter(),
+                                                        ParserContextExtraData::default()));
+                    elem.downcast::<HTMLLinkElement>()
+                        .unwrap()
+                        .set_stylesheet(sheet.clone());
+
+                    let win = window_from_node(&*elem);
+                    win.layout_chan().send(Msg::AddStylesheet(sheet)).unwrap();
+                }
+                StylesheetContextSource::Import(ref import) => {
+                    let import = import.read();
+                    Stylesheet::update_from_bytes(&import.stylesheet,
+                                                  &data,
+                                                  protocol_encoding_label,
+                                                  Some(environment_encoding),
+                                                  Some(&loader),
+                                                  win.css_error_reporter(),
+                                                  ParserContextExtraData::default());
+                }
+            }
+
+            document.invalidate_stylesheets();
+
+            // FIXME: Revisit once consensus is reached at:
+            // https://github.com/whatwg/html/issues/1142
+            successful = metadata.status.map_or(false, |(code, _)| code == 200);
+        }
+
+        let owner = elem.upcast::<Element>().as_stylesheet_owner()
+            .expect("Stylesheet not loaded by <style> or <link> element!");
+        if owner.parser_inserted() {
+            document.decrement_script_blocking_stylesheet_count();
+        }
+
+        let url = self.source.url();
+        document.finish_load(LoadType::Stylesheet(url));
+
+        if let Some(any_failed) = owner.load_finished(successful) {
+            let event = if any_failed { atom!("error") } else { atom!("load") };
+            elem.upcast::<EventTarget>().fire_event(event);
+        }
+    }
+}
+
+pub struct StylesheetLoader<'a> {
+    elem: &'a HTMLElement,
+}
+
+impl<'a> StylesheetLoader<'a> {
+    pub fn for_element(element: &'a HTMLElement) -> Self {
+        StylesheetLoader {
+            elem: element,
+        }
+    }
+}
+
+impl<'a> StylesheetLoader<'a> {
+    pub fn load(&self, source: StylesheetContextSource) {
+        let url = source.url();
+        let context = Arc::new(Mutex::new(StylesheetContext {
+            elem: Trusted::new(&*self.elem),
+            source: source,
+            metadata: None,
+            data: vec![],
+        }));
+
+        let document = document_from_node(self.elem);
+
+        let (action_sender, action_receiver) = ipc::channel().unwrap();
+        let listener = NetworkListener {
+            context: context,
+            task_source: document.window().networking_task_source(),
+            wrapper: Some(document.window().get_runnable_wrapper())
+        };
+        ROUTER.add_route(action_receiver.to_opaque(), box move |message| {
+            listener.notify_fetch(message.to().unwrap());
+        });
+
+
+        let owner = self.elem.upcast::<Element>().as_stylesheet_owner()
+            .expect("Stylesheet not loaded by <style> or <link> element!");
+        let referrer_policy = owner.referrer_policy()
+            .or_else(|| document.get_referrer_policy());
+        owner.increment_pending_loads_count();
+        if owner.parser_inserted() {
+            document.increment_script_blocking_stylesheet_count();
+        }
+
+        let request = RequestInit {
+            url: url.clone(),
+            type_: RequestType::Style,
+            destination: Destination::Style,
+            credentials_mode: CredentialsMode::Include,
+            use_url_credentials: true,
+            origin: document.url(),
+            pipeline_id: Some(self.elem.global().pipeline_id()),
+            referrer_url: Some(document.url()),
+            referrer_policy: referrer_policy,
+            .. RequestInit::default()
+        };
+
+        document.fetch_async(LoadType::Stylesheet(url), request, action_sender);
+    }
+}
+
+impl<'a> StyleStylesheetLoader for StylesheetLoader<'a> {
+    fn request_stylesheet(&self, import: &Arc<RwLock<ImportRule>>) {
+        self.load(StylesheetContextSource::Import(import.clone()))
+    }
+}
diff --git a/components/style/media_queries.rs b/components/style/media_queries.rs
index 9bdfcfc748d..a450995c565 100644
--- a/components/style/media_queries.rs
+++ b/components/style/media_queries.rs
@@ -297,4 +297,8 @@ impl MediaList {
             }
         })
     }
+
+    pub fn is_empty(&self) -> bool {
+        self.media_queries.is_empty()
+    }
 }
diff --git a/components/style/stylesheets.rs b/components/style/stylesheets.rs
index 247c153c46b..bc573eb4bfe 100644
--- a/components/style/stylesheets.rs
+++ b/components/style/stylesheets.rs
@@ -26,6 +26,7 @@ use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
 use style_traits::ToCss;
 use stylist::FnvHashMap;
+use values::specified::url::SpecifiedUrl;
 use viewport::ViewportRule;
 
 
@@ -55,6 +56,12 @@ pub struct Namespaces {
 #[derive(Debug)]
 pub struct CssRules(pub Vec<CssRule>);
 
+impl CssRules {
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+}
+
 pub enum RulesMutateError {
     Syntax,
     IndexSize,
@@ -79,7 +86,8 @@ impl CssRules {
     fn only_ns_or_import(&self) -> bool {
         self.0.iter().all(|r| {
             match *r {
-                CssRule::Namespace(..) /* | CssRule::Import(..) */ => true,
+                CssRule::Namespace(..) |
+                CssRule::Import(..) => true,
                 _ => false
             }
         })
@@ -104,8 +112,9 @@ impl CssRules {
 
         // Step 3, 4
         // XXXManishearth should we also store the namespace map?
-        let (new_rule, new_state) = try!(CssRule::parse(&rule, parent_stylesheet,
-                                                        ParserContextExtraData::default(), state));
+        let (new_rule, new_state) =
+            try!(CssRule::parse(&rule, parent_stylesheet,
+                                ParserContextExtraData::default(), state));
 
         // Step 5
         // Computes the maximum allowed parser state at a given index.
@@ -180,6 +189,7 @@ pub enum CssRule {
     // https://drafts.csswg.org/cssom/#changes-from-5-december-2013
 
     Namespace(Arc<RwLock<NamespaceRule>>),
+    Import(Arc<RwLock<ImportRule>>),
     Style(Arc<RwLock<StyleRule>>),
     Media(Arc<RwLock<MediaRule>>),
     FontFace(Arc<RwLock<FontFaceRule>>),
@@ -235,6 +245,7 @@ impl CssRule {
     pub fn rule_type(&self) -> CssRuleType {
         match *self {
             CssRule::Style(_)     => CssRuleType::Style,
+            CssRule::Import(_)    => CssRuleType::Import,
             CssRule::Media(_)     => CssRuleType::Media,
             CssRule::FontFace(_)  => CssRuleType::FontFace,
             CssRule::Keyframes(_) => CssRuleType::Keyframes,
@@ -246,7 +257,7 @@ impl CssRule {
     fn rule_state(&self) -> State {
         match *self {
             // CssRule::Charset(..) => State::Start,
-            // CssRule::Import(..) => State::Imports,
+            CssRule::Import(..) => State::Imports,
             CssRule::Namespace(..) => State::Namespaces,
             _ => State::Body,
         }
@@ -254,10 +265,19 @@ impl CssRule {
 
     /// Call `f` with the slice of rules directly contained inside this rule.
     ///
-    /// Note that only some types of rules can contain rules. An empty slice is used for others.
+    /// Note that only some types of rules can contain rules. An empty slice is
+    /// used for others.
     pub fn with_nested_rules_and_mq<F, R>(&self, mut f: F) -> R
     where F: FnMut(&[CssRule], Option<&MediaList>) -> R {
         match *self {
+            CssRule::Import(ref lock) => {
+                let rule = lock.read();
+                let media = rule.stylesheet.media.read();
+                let rules = rule.stylesheet.rules.read();
+                // FIXME(emilio): Include the nested rules if the stylesheet is
+                // loaded.
+                f(&rules.0, Some(&media))
+            }
             CssRule::Namespace(_) |
             CssRule::Style(_) |
             CssRule::FontFace(_) |
@@ -294,6 +314,7 @@ impl CssRule {
         let mut rule_parser = TopLevelRuleParser {
             stylesheet_origin: parent_stylesheet.origin,
             context: context,
+            loader: None,
             state: Cell::new(state),
             namespaces: &mut namespaces,
         };
@@ -315,6 +336,7 @@ impl ToCss for CssRule {
     fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
         match *self {
             CssRule::Namespace(ref lock) => lock.read().to_css(dest),
+            CssRule::Import(ref lock) => lock.read().to_css(dest),
             CssRule::Style(ref lock) => lock.read().to_css(dest),
             CssRule::FontFace(ref lock) => lock.read().to_css(dest),
             CssRule::Viewport(ref lock) => lock.read().to_css(dest),
@@ -346,6 +368,34 @@ impl ToCss for NamespaceRule {
     }
 }
 
+
+/// The [`@import`][import] at-rule.
+///
+/// [import]: https://drafts.csswg.org/css-cascade-3/#at-import
+#[derive(Debug)]
+pub struct ImportRule {
+    pub url: SpecifiedUrl,
+
+    /// The stylesheet is always present.
+    ///
+    /// It contains an empty list of rules and namespace set that is updated
+    /// when it loads.
+    pub stylesheet: Arc<Stylesheet>,
+}
+
+impl ToCss for ImportRule {
+    fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
+        try!(dest.write_str("@import "));
+        try!(self.url.to_css(dest));
+        let media = self.stylesheet.media.read();
+        if !media.is_empty() {
+            try!(dest.write_str(" "));
+            try!(media.to_css(dest));
+        }
+        dest.write_str(";")
+    }
+}
+
 #[derive(Debug)]
 pub struct KeyframesRule {
     pub name: Atom,
@@ -421,54 +471,102 @@ impl Stylesheet {
                       environment_encoding: Option<EncodingRef>,
                       origin: Origin,
                       media: MediaList,
+                      stylesheet_loader: Option<&StylesheetLoader>,
                       error_reporter: Box<ParseErrorReporter + Send>,
                       extra_data: ParserContextExtraData)
                       -> Stylesheet {
         let (string, _) = decode_stylesheet_bytes(
             bytes, protocol_encoding_label, environment_encoding);
-        Stylesheet::from_str(&string, base_url, origin, media, error_reporter, extra_data)
+        Stylesheet::from_str(&string,
+                             base_url,
+                             origin,
+                             media,
+                             stylesheet_loader,
+                             error_reporter,
+                             extra_data)
     }
 
-    pub fn from_str(css: &str, base_url: ServoUrl, origin: Origin, media: MediaList,
-                    error_reporter: Box<ParseErrorReporter + Send>,
-                    extra_data: ParserContextExtraData) -> Stylesheet {
-        let mut namespaces = Namespaces::default();
-        let mut rules = vec![];
-        let dirty_on_viewport_size_change;
+    pub fn update_from_bytes(existing: &Stylesheet,
+                             bytes: &[u8],
+                             protocol_encoding_label: Option<&str>,
+                             environment_encoding: Option<EncodingRef>,
+                             stylesheet_loader: Option<&StylesheetLoader>,
+                             error_reporter: Box<ParseErrorReporter + Send>,
+                             extra_data: ParserContextExtraData) {
+        assert!(existing.rules.read().is_empty());
+        let (string, _) = decode_stylesheet_bytes(
+            bytes, protocol_encoding_label, environment_encoding);
+        Self::update_from_str(existing,
+                              &string,
+                              stylesheet_loader,
+                              error_reporter,
+                              extra_data)
+    }
+
+    pub fn update_from_str(existing: &Stylesheet,
+                           css: &str,
+                           stylesheet_loader: Option<&StylesheetLoader>,
+                           error_reporter: Box<ParseErrorReporter + Send>,
+                           extra_data: ParserContextExtraData) {
+        let mut rules = existing.rules.write();
+        let mut namespaces = existing.namespaces.write();
+
+        assert!(rules.is_empty());
+
+        let mut input = Parser::new(css);
+        let rule_parser = TopLevelRuleParser {
+            stylesheet_origin: existing.origin,
+            namespaces: &mut namespaces,
+            loader: stylesheet_loader,
+            context: ParserContext::new_with_extra_data(existing.origin,
+                                                        &existing.base_url,
+                                                        error_reporter,
+                                                        extra_data),
+            state: Cell::new(State::Start),
+        };
+
+        input.look_for_viewport_percentages();
+
         {
-            let rule_parser = TopLevelRuleParser {
-                stylesheet_origin: origin,
-                namespaces: &mut namespaces,
-                context: ParserContext::new_with_extra_data(origin, &base_url, error_reporter, extra_data),
-                state: Cell::new(State::Start),
-            };
-            let mut input = Parser::new(css);
-            input.look_for_viewport_percentages();
-            {
-                let mut iter = RuleListParser::new_for_stylesheet(&mut input, rule_parser);
-                while let Some(result) = iter.next() {
-                    match result {
-                        Ok(rule) => rules.push(rule),
-                        Err(range) => {
-                            let pos = range.start;
-                            let message = format!("Invalid rule: '{}'", iter.input.slice(range));
-                            log_css_error(iter.input, pos, &*message, &iter.parser.context);
-                        }
+            let mut iter = RuleListParser::new_for_stylesheet(&mut input, rule_parser);
+            while let Some(result) = iter.next() {
+                match result {
+                    Ok(rule) => rules.0.push(rule),
+                    Err(range) => {
+                        let pos = range.start;
+                        let message = format!("Invalid rule: '{}'", iter.input.slice(range));
+                        log_css_error(iter.input, pos, &*message, &iter.parser.context);
                     }
                 }
             }
-            dirty_on_viewport_size_change = input.seen_viewport_percentages();
         }
 
-        Stylesheet {
+        existing.dirty_on_viewport_size_change
+            .store(input.seen_viewport_percentages(), Ordering::Release);
+    }
+
+    pub fn from_str(css: &str, base_url: ServoUrl, origin: Origin,
+                    media: MediaList,
+                    stylesheet_loader: Option<&StylesheetLoader>,
+                    error_reporter: Box<ParseErrorReporter + Send>,
+                    extra_data: ParserContextExtraData) -> Stylesheet {
+        let s = Stylesheet {
             origin: origin,
             base_url: base_url,
-            namespaces: RwLock::new(namespaces),
-            rules: CssRules::new(rules),
+            namespaces: RwLock::new(Namespaces::default()),
+            rules: CssRules::new(vec![]),
             media: Arc::new(RwLock::new(media)),
-            dirty_on_viewport_size_change: AtomicBool::new(dirty_on_viewport_size_change),
+            dirty_on_viewport_size_change: AtomicBool::new(false),
             disabled: AtomicBool::new(false),
-        }
+        };
+
+        Self::update_from_str(&s,
+                              css,
+                              stylesheet_loader,
+                              error_reporter,
+                              extra_data);
+
+        s
     }
 
     pub fn dirty_on_viewport_size_change(&self) -> bool {
@@ -563,9 +661,20 @@ rule_filter! {
     effective_keyframes_rules(Keyframes => KeyframesRule),
 }
 
+/// The stylesheet loader is the abstraction used to trigger network requests
+/// for `@import` rules.
+pub trait StylesheetLoader {
+    /// Request a stylesheet after parsing a given `@import` rule.
+    ///
+    /// The called code is responsible to update the `stylesheet` rules field
+    /// when the sheet is done loading.
+    fn request_stylesheet(&self, import: &Arc<RwLock<ImportRule>>);
+}
+
 struct TopLevelRuleParser<'a> {
     stylesheet_origin: Origin,
     namespaces: &'a mut Namespaces,
+    loader: Option<&'a StylesheetLoader>,
     context: ParserContext<'a>,
     state: Cell<State>,
 }
@@ -612,8 +721,38 @@ impl<'a> AtRuleParser for TopLevelRuleParser<'a> {
             "import" => {
                 if self.state.get() <= State::Imports {
                     self.state.set(State::Imports);
-                    // TODO: support @import
-                    return Err(())  // "@import is not supported yet"
+                    let url = try!(input.expect_url_or_string());
+                    let url =
+                        try!(SpecifiedUrl::parse_from_string(url,
+                                                             &self.context));
+
+                    let media =
+                        Arc::new(RwLock::new(parse_media_query_list(input)));
+
+                    let is_valid_url = url.url().is_some();
+
+                    let import_rule = Arc::new(RwLock::new(
+                        ImportRule {
+                            url: url,
+                            stylesheet: Arc::new(Stylesheet {
+                                rules: Arc::new(RwLock::new(CssRules(vec![]))),
+                                media: media,
+                                origin: self.context.stylesheet_origin,
+                                base_url: self.context.base_url.clone(),
+                                namespaces: RwLock::new(Namespaces::default()),
+                                dirty_on_viewport_size_change: AtomicBool::new(false),
+                                disabled: AtomicBool::new(false),
+                            })
+                        }
+                    ));
+
+                    if is_valid_url {
+                        let loader = self.loader
+                            .expect("Expected a stylesheet loader for @import");
+                        loader.request_stylesheet(&import_rule);
+                    }
+
+                    return Ok(AtRuleType::WithoutBlock(CssRule::Import(import_rule)))
                 } else {
                     self.state.set(State::Invalid);
                     return Err(())  // "@import must be before any rule but @charset"
diff --git a/components/style/stylist.rs b/components/style/stylist.rs
index 33f49f08c3e..4cb4a65b081 100644
--- a/components/style/stylist.rs
+++ b/components/style/stylist.rs
@@ -165,6 +165,25 @@ impl Stylist {
             self.add_stylesheet(stylesheet);
         }
 
+        debug!("Stylist stats:");
+        debug!(" - Got {} sibling-affecting selectors",
+               self.sibling_affecting_selectors.len());
+        debug!(" - Got {} non-common-style-attribute-affecting selectors",
+               self.non_common_style_affecting_attributes_selectors.len());
+        debug!(" - Got {} deps for style-hint calculation",
+               self.state_deps.len());
+
+        SelectorImpl::each_precomputed_pseudo_element(|pseudo| {
+            // TODO: Consider not doing this and just getting the rules on the
+            // fly. It should be a bit slower, but we'd take rid of the
+            // extra field, and avoid this precomputation entirely.
+            if let Some(map) = self.pseudos_map.remove(&pseudo) {
+                let mut declarations = vec![];
+                map.user_agent.get_universal_rules(&mut declarations);
+                self.precomputed_pseudo_element_decls.insert(pseudo, declarations);
+            }
+        });
+
         self.is_device_dirty = false;
         true
     }
@@ -211,6 +230,10 @@ impl Stylist {
                         }
                     }
                 }
+                CssRule::Import(ref import) => {
+                    let import = import.read();
+                    self.add_stylesheet(&import.stylesheet)
+                }
                 CssRule::Keyframes(ref keyframes_rule) => {
                     let keyframes_rule = keyframes_rule.read();
                     debug!("Found valid keyframes rule: {:?}", *keyframes_rule);
@@ -250,6 +273,7 @@ impl Stylist {
         });
     }
 
+
     /// Computes the style for a given "precomputed" pseudo-element, taking the
     /// universal rules and applying them.
     ///
diff --git a/components/style/values/specified/url.rs b/components/style/values/specified/url.rs
index d3100586c52..878fbc018b8 100644
--- a/components/style/values/specified/url.rs
+++ b/components/style/values/specified/url.rs
@@ -11,6 +11,7 @@ use parser::{Parse, ParserContext};
 #[cfg(feature = "gecko")]
 use parser::ParserContextExtraData;
 use servo_url::ServoUrl;
+use std::borrow::Cow;
 use std::fmt::{self, Write};
 use std::ptr;
 use std::sync::Arc;
@@ -76,7 +77,14 @@ pub struct SpecifiedUrl {
 impl Parse for SpecifiedUrl {
     fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ()> {
         let url = try!(input.expect_url());
+        Self::parse_from_string(url, context)
+    }
+}
 
+impl SpecifiedUrl {
+    pub fn parse_from_string<'a>(url: Cow<'a, str>,
+                                 context: &ParserContext)
+                                 -> Result<Self, ()> {
         let extra_data = match UrlExtraData::make_from(context) {
             Some(extra_data) => extra_data,
             None => {
@@ -96,9 +104,7 @@ impl Parse for SpecifiedUrl {
             extra_data: extra_data,
         })
     }
-}
 
-impl SpecifiedUrl {
     pub fn extra_data(&self) -> &UrlExtraData {
         &self.extra_data
     }
diff --git a/ports/geckolib/glue.rs b/ports/geckolib/glue.rs
index 394653afd8e..dcec9a5c1ac 100644
--- a/ports/geckolib/glue.rs
+++ b/ports/geckolib/glue.rs
@@ -60,6 +60,7 @@ use style::thread_state;
 use style::timer::Timer;
 use style::traversal::{recalc_style_at, DomTraversalContext, PerLevelTraversalData};
 use style_traits::ToCss;
+use stylesheet_loader::StylesheetLoader;
 
 /*
  * For Gecko->Servo function calls, we need to redeclare the same signature that was declared in
@@ -232,8 +233,10 @@ pub extern "C" fn Servo_StyleSheet_Empty(mode: SheetParsingMode) -> RawServoStyl
         SheetParsingMode::eUserSheetFeatures => Origin::User,
         SheetParsingMode::eAgentSheetFeatures => Origin::UserAgent,
     };
+    let loader = StylesheetLoader::new();
     let sheet = Arc::new(Stylesheet::from_str(
-        "", url, origin, Default::default(), Box::new(StdoutErrorReporter), extra_data));
+        "", url, origin, Default::default(), Some(&loader),
+        Box::new(StdoutErrorReporter), extra_data));
     unsafe {
         transmute(sheet)
     }
@@ -262,8 +265,10 @@ pub extern "C" fn Servo_StyleSheet_FromUTF8Bytes(data: *const nsACString,
         referrer: Some(GeckoArcURI::new(referrer)),
         principal: Some(GeckoArcPrincipal::new(principal)),
     }};
+    let loader = StylesheetLoader::new();
     let sheet = Arc::new(Stylesheet::from_str(
-        input, url, origin, Default::default(), Box::new(StdoutErrorReporter), extra_data));
+        input, url, origin, Default::default(), Some(&loader),
+        Box::new(StdoutErrorReporter), extra_data));
     unsafe {
         transmute(sheet)
     }
diff --git a/ports/geckolib/lib.rs b/ports/geckolib/lib.rs
index 0087e6aece6..1225045e45c 100644
--- a/ports/geckolib/lib.rs
+++ b/ports/geckolib/lib.rs
@@ -18,6 +18,7 @@ extern crate style_traits;
 
 #[allow(non_snake_case)]
 pub mod glue;
+mod stylesheet_loader;
 
 // FIXME(bholley): This should probably go away once we harmonize the allocators.
 #[no_mangle]
diff --git a/ports/geckolib/stylesheet_loader.rs b/ports/geckolib/stylesheet_loader.rs
new file mode 100644
index 00000000000..9db89333747
--- /dev/null
+++ b/ports/geckolib/stylesheet_loader.rs
@@ -0,0 +1,21 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * 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/. */
+
+use parking_lot::RwLock;
+use std::sync::Arc;
+use style::stylesheets::{ImportRule, StylesheetLoader as StyleStylesheetLoader};
+
+pub struct StylesheetLoader;
+
+impl StylesheetLoader {
+    pub fn new() -> Self {
+        StylesheetLoader
+    }
+}
+
+impl StyleStylesheetLoader for StylesheetLoader {
+    fn request_stylesheet(&self, _import: &Arc<RwLock<ImportRule>>) {
+        // FIXME(emilio): Implement `@import` in stylo.
+    }
+}
diff --git a/tests/unit/style/media_queries.rs b/tests/unit/style/media_queries.rs
index 8c91a5b52bb..ac5a9b501c2 100644
--- a/tests/unit/style/media_queries.rs
+++ b/tests/unit/style/media_queries.rs
@@ -29,7 +29,8 @@ fn test_media_rule<F>(css: &str, callback: F) where F: Fn(&MediaList, &str) {
     let url = ServoUrl::parse("http://localhost").unwrap();
     let stylesheet = Stylesheet::from_str(
         css, url, Origin::Author, Default::default(),
-        Box::new(CSSErrorReporterTest), ParserContextExtraData::default());
+        None, Box::new(CSSErrorReporterTest),
+        ParserContextExtraData::default());
     let mut rule_count = 0;
     media_queries(&stylesheet.rules.read().0, &mut |mq| {
         rule_count += 1;
@@ -53,7 +54,8 @@ fn media_query_test(device: &Device, css: &str, expected_rule_count: usize) {
     let url = ServoUrl::parse("http://localhost").unwrap();
     let ss = Stylesheet::from_str(
         css, url, Origin::Author, Default::default(),
-        Box::new(CSSErrorReporterTest), ParserContextExtraData::default());
+        None, Box::new(CSSErrorReporterTest),
+        ParserContextExtraData::default());
     let mut rule_count = 0;
     ss.effective_style_rules(device, |_| rule_count += 1);
     assert!(rule_count == expected_rule_count, css.to_owned());
diff --git a/tests/unit/style/stylesheets.rs b/tests/unit/style/stylesheets.rs
index d4c8bcc28a1..40ad06d8e4f 100644
--- a/tests/unit/style/stylesheets.rs
+++ b/tests/unit/style/stylesheets.rs
@@ -52,6 +52,7 @@ fn test_parse_stylesheet() {
         }";
     let url = ServoUrl::parse("about::test").unwrap();
     let stylesheet = Stylesheet::from_str(css, url.clone(), Origin::UserAgent, Default::default(),
+                                          None,
                                           Box::new(CSSErrorReporterTest),
                                           ParserContextExtraData::default());
     let mut namespaces = Namespaces::default();
@@ -332,7 +333,9 @@ fn test_report_error_stylesheet() {
 
     let errors = error_reporter.errors.clone();
 
-    Stylesheet::from_str(css, url, Origin::UserAgent, Default::default(), error_reporter,
+    Stylesheet::from_str(css, url, Origin::UserAgent, Default::default(),
+                         None,
+                         error_reporter,
                          ParserContextExtraData::default());
 
     let mut errors = errors.lock().unwrap();
diff --git a/tests/unit/style/viewport.rs b/tests/unit/style/viewport.rs
index 9a3bc773a9c..2ca9733afc2 100644
--- a/tests/unit/style/viewport.rs
+++ b/tests/unit/style/viewport.rs
@@ -25,6 +25,7 @@ macro_rules! stylesheet {
             ServoUrl::parse("http://localhost").unwrap(),
             Origin::$origin,
             Default::default(),
+            None,
             $error_reporter,
             ParserContextExtraData::default()
         ))
diff --git a/tests/unit/stylo/lib.rs b/tests/unit/stylo/lib.rs
index d28f0663d0e..35fcdd01602 100644
--- a/tests/unit/stylo/lib.rs
+++ b/tests/unit/stylo/lib.rs
@@ -16,5 +16,8 @@ extern crate style_traits;
 
 mod sanity_checks;
 
+#[path = "../../../ports/geckolib/stylesheet_loader.rs"]
+mod stylesheet_loader;
+
 mod servo_function_signatures;
 
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-001.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-001.htm.ini
deleted file mode 100644
index 0a433e1c565..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-001.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-001.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-007.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-007.htm.ini
deleted file mode 100644
index 0b114bb4226..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-007.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-007.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-008.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-008.htm.ini
deleted file mode 100644
index 6761cde0201..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-008.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-008.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-009.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-009.htm.ini
deleted file mode 100644
index 8fc7f684eac..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-009.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-009.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-012.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-012.htm.ini
deleted file mode 100644
index 095028505c8..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-012.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-012.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-014.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-014.htm.ini
deleted file mode 100644
index 869c7c53ab4..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-014.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-014.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-015.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-015.htm.ini
deleted file mode 100644
index 5049e881c1a..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-015.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-015.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-016.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-016.htm.ini
deleted file mode 100644
index 3b63a1c1f46..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-016.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-016.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-019.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-019.htm.ini
deleted file mode 100644
index b1eed1ecff9..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-019.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-019.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-020.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-020.htm.ini
deleted file mode 100644
index 0503e133961..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-020.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-020.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-021.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-021.htm.ini
deleted file mode 100644
index e8a1c3f0258..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-021.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-021.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-024.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-024.htm.ini
deleted file mode 100644
index 852ecb54c82..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-024.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-024.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-025.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-025.htm.ini
deleted file mode 100644
index dbeb381460f..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-025.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-025.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-026.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-026.htm.ini
deleted file mode 100644
index 863ce667cfa..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-026.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-026.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-027.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-027.htm.ini
deleted file mode 100644
index 43a7809a606..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-027.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-027.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-028.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-028.htm.ini
deleted file mode 100644
index ebf27be93de..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-028.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-028.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-029.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-029.htm.ini
deleted file mode 100644
index 99eee9d118e..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-029.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-029.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-030.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-030.htm.ini
deleted file mode 100644
index 7bb89c7554c..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-030.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-030.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-040.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-040.htm.ini
deleted file mode 100644
index f7815fd6097..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-040.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-040.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-041.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-041.htm.ini
deleted file mode 100644
index 4d4c2c20a7b..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-041.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-041.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-042.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-042.htm.ini
deleted file mode 100644
index b791ae70d87..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-042.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-042.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-043.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-043.htm.ini
deleted file mode 100644
index f7aaa086ec8..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-043.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-043.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-044.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-044.htm.ini
deleted file mode 100644
index 2e344f7582b..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-044.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-044.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-045.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-045.htm.ini
deleted file mode 100644
index 58ec1784998..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-045.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-045.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-046.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-046.htm.ini
deleted file mode 100644
index 7f6c169cc3c..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-046.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-046.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-047.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-047.htm.ini
deleted file mode 100644
index 1f2c8c5fbee..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-047.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-047.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-048.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-048.htm.ini
deleted file mode 100644
index 060244c08b5..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-048.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-048.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-053.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-053.htm.ini
deleted file mode 100644
index 903080bb09b..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-053.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-053.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-charset-060.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-charset-060.htm.ini
deleted file mode 100644
index 76eb1b5c2f4..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-charset-060.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-charset-060.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-import-002.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-import-002.htm.ini
deleted file mode 100644
index e6c008e9939..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-import-002.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-import-002.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-import-003.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-import-003.htm.ini
deleted file mode 100644
index 499e7192843..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-import-003.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-import-003.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-import-005.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-import-005.htm.ini
deleted file mode 100644
index 0f407b5eace..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-import-005.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-import-005.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-import-006.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-import-006.htm.ini
deleted file mode 100644
index a48e83e2109..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-import-006.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-import-006.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-import-007.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-import-007.htm.ini
deleted file mode 100644
index d288b277cfc..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-import-007.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-import-007.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-keywords-000.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-keywords-000.htm.ini
deleted file mode 100644
index dcc06995155..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-keywords-000.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-keywords-000.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-rule-005.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-rule-005.htm.ini
deleted file mode 100644
index 38613180fb3..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-rule-005.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-rule-005.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/at-rule-010.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/at-rule-010.htm.ini
deleted file mode 100644
index db7f13e3e70..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/at-rule-010.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[at-rule-010.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/c11-import-000.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/c11-import-000.htm.ini
deleted file mode 100644
index 91cf2f4f4ad..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/c11-import-000.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[c11-import-000.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/cascade-012.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/cascade-012.htm.ini
deleted file mode 100644
index eb899ae0891..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/cascade-012.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[cascade-012.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/core-syntax-009.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/core-syntax-009.htm.ini
deleted file mode 100644
index 7c398b6a6dd..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/core-syntax-009.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[core-syntax-009.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/eof-005.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/eof-005.htm.ini
deleted file mode 100644
index 7f7d0a6ba56..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/eof-005.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[eof-005.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/eof-006.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/eof-006.htm.ini
deleted file mode 100644
index 09102883ad8..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/eof-006.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[eof-006.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/media-dependency-002.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/media-dependency-002.htm.ini
deleted file mode 100644
index 372354710d3..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/media-dependency-002.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[media-dependency-002.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/media-dependency-004.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/media-dependency-004.htm.ini
deleted file mode 100644
index a9d7980f8af..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/media-dependency-004.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[media-dependency-004.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/media-dependency-005.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/media-dependency-005.htm.ini
deleted file mode 100644
index a4860d3d971..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/media-dependency-005.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[media-dependency-005.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/css21_dev/html4/uri-001.htm.ini b/tests/wpt/metadata-css/css21_dev/html4/uri-001.htm.ini
deleted file mode 100644
index 463a8ada21e..00000000000
--- a/tests/wpt/metadata-css/css21_dev/html4/uri-001.htm.ini
+++ /dev/null
@@ -1,3 +0,0 @@
-[uri-001.htm]
-  type: reftest
-  expected: FAIL
diff --git a/tests/wpt/metadata-css/cssom-1_dev/html/cssimportrule.htm.ini b/tests/wpt/metadata-css/cssom-1_dev/html/cssimportrule.htm.ini
index b09eb56a50f..b6f619dbf5f 100644
--- a/tests/wpt/metadata-css/cssom-1_dev/html/cssimportrule.htm.ini
+++ b/tests/wpt/metadata-css/cssom-1_dev/html/cssimportrule.htm.ini
@@ -1,11 +1,5 @@
 [cssimportrule.htm]
   type: testharness
-  [CSSRule and CSSImportRule types]
-    expected: FAIL
-
-  [Type of CSSRule#type and constant values]
-    expected: FAIL
-
   [Existence and writability of CSSRule attributes]
     expected: FAIL
 
diff --git a/tests/wpt/metadata-css/cssom-1_dev/html/index-003.htm.ini b/tests/wpt/metadata-css/cssom-1_dev/html/index-003.htm.ini
index e6f60a1c5f5..066d022415b 100644
--- a/tests/wpt/metadata-css/cssom-1_dev/html/index-003.htm.ini
+++ b/tests/wpt/metadata-css/cssom-1_dev/html/index-003.htm.ini
@@ -1,8 +1,5 @@
 [index-003.htm]
   type: testharness
-  [@import rule is expected to be @import url("main.css")]
-    expected: FAIL
-
   [page rule is expected to be @page :first]
     expected: FAIL
 
diff --git a/tests/wpt/metadata-css/cssom-1_dev/html/interfaces.htm.ini b/tests/wpt/metadata-css/cssom-1_dev/html/interfaces.htm.ini
index 7747a24e315..a2fdf663996 100644
--- a/tests/wpt/metadata-css/cssom-1_dev/html/interfaces.htm.ini
+++ b/tests/wpt/metadata-css/cssom-1_dev/html/interfaces.htm.ini
@@ -132,18 +132,6 @@
   [CSSRule interface: style_element.sheet.cssRules[0\] must inherit property "parentRule" with the proper type (10)]
     expected: FAIL
 
-  [CSSImportRule interface: existence and properties of interface object]
-    expected: FAIL
-
-  [CSSImportRule interface object length]
-    expected: FAIL
-
-  [CSSImportRule interface: existence and properties of interface prototype object]
-    expected: FAIL
-
-  [CSSImportRule interface: existence and properties of interface prototype object's "constructor" property]
-    expected: FAIL
-
   [CSSImportRule interface: attribute href]
     expected: FAIL
 
diff --git a/tests/wpt/metadata/fetch/nosniff/stylesheet.html.ini b/tests/wpt/metadata/fetch/nosniff/stylesheet.html.ini
new file mode 100644
index 00000000000..7b0678423d1
--- /dev/null
+++ b/tests/wpt/metadata/fetch/nosniff/stylesheet.html.ini
@@ -0,0 +1,14 @@
+[stylesheet.html]
+  type: testharness
+  [URL query: ]
+    expected: FAIL
+
+  [URL query: ?type=]
+    expected: FAIL
+
+  [URL query: ?type=x]
+    expected: FAIL
+
+  [URL query: ?type=x/x]
+    expected: FAIL
+
diff --git a/tests/wpt/metadata/html/semantics/document-metadata/the-link-element/link-style-error-01.html.ini b/tests/wpt/metadata/html/semantics/document-metadata/the-link-element/link-style-error-01.html.ini
new file mode 100644
index 00000000000..ed2ecc503bb
--- /dev/null
+++ b/tests/wpt/metadata/html/semantics/document-metadata/the-link-element/link-style-error-01.html.ini
@@ -0,0 +1,5 @@
+[link-style-error-01.html]
+  type: testharness
+  [Should get an error event for a text/plain response.]
+    expected: FAIL
+
diff --git a/tests/wpt/metadata/html/semantics/document-metadata/the-style-element/style_events.html.ini b/tests/wpt/metadata/html/semantics/document-metadata/the-style-element/style_events.html.ini
deleted file mode 100644
index bf45e5bd993..00000000000
--- a/tests/wpt/metadata/html/semantics/document-metadata/the-style-element/style_events.html.ini
+++ /dev/null
@@ -1,9 +0,0 @@
-[style_events.html]
-  type: testharness
-  expected: TIMEOUT
-  [If the style is loaded successfully, the 'load' event must be fired]
-    expected: NOTRUN
-
-  [If the style is loaded unsuccessfully, the 'error' event must be fired]
-    expected: NOTRUN
-
diff --git a/tests/wpt/metadata/old-tests/submission/Opera/script_scheduling/106-import.html.ini b/tests/wpt/metadata/old-tests/submission/Opera/script_scheduling/106-import.html.ini
deleted file mode 100644
index e138b39ddec..00000000000
--- a/tests/wpt/metadata/old-tests/submission/Opera/script_scheduling/106-import.html.ini
+++ /dev/null
@@ -1,5 +0,0 @@
-[106-import.html]
-  type: testharness
-  [ scheduler: stylesheets blocking scripts]
-    expected: FAIL
-
diff --git a/tests/wpt/mozilla/meta/MANIFEST.json b/tests/wpt/mozilla/meta/MANIFEST.json
index df134a0abb9..ca2f3db7589 100644
--- a/tests/wpt/mozilla/meta/MANIFEST.json
+++ b/tests/wpt/mozilla/meta/MANIFEST.json
@@ -6638,6 +6638,12 @@
             "url": "/_mozilla/css/float_relative_to_position.html"
           }
         ],
+        "css/import_serialization.html": [
+          {
+            "path": "css/import_serialization.html",
+            "url": "/_mozilla/css/import_serialization.html"
+          }
+        ],
         "css/matchMedia.html": [
           {
             "path": "css/matchMedia.html",
diff --git a/tests/wpt/mozilla/tests/css/import_serialization.html b/tests/wpt/mozilla/tests/css/import_serialization.html
new file mode 100644
index 00000000000..44c828db3cb
--- /dev/null
+++ b/tests/wpt/mozilla/tests/css/import_serialization.html
@@ -0,0 +1,16 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>CSS Test: @import rules are correctly serialized</title>
+<style id="test">
+  @import url("foo.css");
+  @import url("foo.css") print;
+</style>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+test(function() {
+  var rules = document.styleSheets[0].cssRules;
+  assert_equals(rules[0].cssText, "@import url(\"foo.css\");");
+  assert_equals(rules[1].cssText, "@import url(\"foo.css\") print;");
+})
+</script>
diff --git a/tests/wpt/mozilla/tests/mozilla/interfaces.html b/tests/wpt/mozilla/tests/mozilla/interfaces.html
index a658a8eb346..85e6335aafb 100644
--- a/tests/wpt/mozilla/tests/mozilla/interfaces.html
+++ b/tests/wpt/mozilla/tests/mozilla/interfaces.html
@@ -22,6 +22,7 @@ test_interfaces([
   "CSS",
   "CSSFontFaceRule",
   "CSSGroupingRule",
+  "CSSImportRule",
   "CSSKeyframeRule",
   "CSSKeyframesRule",
   "CSSMediaRule",