Pass CSS loader to Servo for insertRule.

components/script/dom/cssrulelist.rs

@@ -92,7 +92,10 @@ impl CSSRuleList {
         let parent_stylesheet = self.parent_stylesheet.style_stylesheet();
         let new_rule = {
             let mut guard = parent_stylesheet.shared_lock.write();
-            css_rules.write_with(&mut guard).insert_rule(rule, parent_stylesheet, index, nested)?
+            // FIXME We should probably pass in a proper StylesheetLoader.
+            //       See servo/servo#16240
+            css_rules.write_with(&mut guard).insert_rule(rule, parent_stylesheet,
+                                                         index, nested, None)?
             // Drop `guard` here,
             // CSSRule::new_specific re-acquires the lock for @support and @media.
         };

components/style/stylesheets.rs

@@ -106,7 +106,12 @@ impl CssRules {
     }
 
     /// https://drafts.csswg.org/cssom/#insert-a-css-rule
-    pub fn insert_rule(&mut self, rule: &str, parent_stylesheet: &Stylesheet, index: usize, nested: bool)
+    pub fn insert_rule(&mut self,
+                       rule: &str,
+                       parent_stylesheet: &Stylesheet,
+                       index: usize,
+                       nested: bool,
+                       loader: Option<&StylesheetLoader>)
                        -> Result<CssRule, RulesMutateError> {
         // Step 1, 2
         if index > self.0.len() {
@@ -126,7 +131,8 @@ impl CssRules {
         // XXXManishearth should we also store the namespace map?
         let (new_rule, new_state) =
             try!(CssRule::parse(&rule, parent_stylesheet,
-                                ParserContextExtraData::default(), state));
+                                ParserContextExtraData::default(),
+                                state, loader));
 
         // Step 5
         // Computes the maximum allowed parser state at a given index.
@@ -343,7 +349,8 @@ impl CssRule {
     pub fn parse(css: &str,
                  parent_stylesheet: &Stylesheet,
                  extra_data: ParserContextExtraData,
-                 state: Option<State>)
+                 state: Option<State>,
+                 loader: Option<&StylesheetLoader>)
                  -> Result<(Self, State), SingleRuleParseError> {
         let error_reporter = MemoryHoleReporter;
         let mut namespaces = parent_stylesheet.namespaces.write();
@@ -359,7 +366,7 @@ impl CssRule {
             stylesheet_origin: parent_stylesheet.origin,
             context: context,
             shared_lock: &parent_stylesheet.shared_lock,
-            loader: None,
+            loader: loader,
             state: Cell::new(state),
             namespaces: &mut namespaces,
         };

ports/geckolib/glue.rs

@@ -510,13 +510,24 @@ pub extern "C" fn Servo_CssRules_ListTypes(rules: ServoCssRulesBorrowed,
 }
 
 #[no_mangle]
-pub extern "C" fn Servo_CssRules_InsertRule(rules: ServoCssRulesBorrowed, sheet: RawServoStyleSheetBorrowed,
+pub extern "C" fn Servo_CssRules_InsertRule(rules: ServoCssRulesBorrowed,
-                                            rule: *const nsACString, index: u32, nested: bool,
+                                            sheet: RawServoStyleSheetBorrowed,
+                                            rule: *const nsACString,
+                                            index: u32,
+                                            nested: bool,
+                                            loader: *mut Loader,
+                                            gecko_stylesheet: *mut ServoStyleSheet,
                                             rule_type: *mut u16) -> nsresult {
     let sheet = Stylesheet::as_arc(&sheet);
+    let loader = if loader.is_null() {
+        None
+    } else {
+        Some(StylesheetLoader::new(loader, gecko_stylesheet))
+    };
+    let loader = loader.as_ref().map(|loader| loader as &StyleStylesheetLoader);
     let rule = unsafe { rule.as_ref().unwrap().as_str_unchecked() };
     write_locked_arc(rules, |rules: &mut CssRules| {
-        match rules.insert_rule(rule, sheet, index as usize, nested) {
+        match rules.insert_rule(rule, sheet, index as usize, nested, loader) {
             Ok(new_rule) => {
                 *unsafe { rule_type.as_mut().unwrap() } = new_rule.rule_type() as u16;
                 nsresult::NS_OK