Add insertRule() and deleteRule() on CSSStyleSheet

components/script/dom/cssrule.rs

@@ -73,6 +73,12 @@ impl CSSRule {
             StyleCssRule::Viewport(s) => Root::upcast(CSSViewportRule::new(window, parent, s)),
         }
     }
+
+    /// Sets owner sheet/rule to null
+    pub fn disown(&self) {
+        self.parent.set(None);
+        // should set parent rule to None when we add parent rule support
+    }
 }
 
 impl CSSRuleMethods for CSSRule {

components/script/dom/cssrulelist.rs

@@ -2,14 +2,19 @@
  * 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::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::CSSRuleListBinding;
 use dom::bindings::codegen::Bindings::CSSRuleListBinding::CSSRuleListMethods;
+use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
+use dom::bindings::error::{Error, ErrorResult, Fallible};
 use dom::bindings::js::{JS, MutNullableHeap, Root};
 use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::cssrule::CSSRule;
 use dom::cssstylesheet::CSSStyleSheet;
 use dom::window::Window;
-use style::stylesheets::CssRules;
+use style::parser::ParserContextExtraData;
+use style::stylesheets::{CssRules, Origin};
+use style::stylesheets::CssRule as StyleCssRule;
 
 no_jsmanaged_fields!(CssRules);
 
@@ -19,7 +24,7 @@ pub struct CSSRuleList {
     sheet: JS<CSSStyleSheet>,
     #[ignore_heap_size_of = "Arc"]
     rules: CssRules,
-    dom_rules: Vec<MutNullableHeap<JS<CSSRule>>>
+    dom_rules: DOMRefCell<Vec<MutNullableHeap<JS<CSSRule>>>>
 }
 
 impl CSSRuleList {
@@ -30,7 +35,7 @@ impl CSSRuleList {
             reflector_: Reflector::new(),
             sheet: JS::from_ref(sheet),
             rules: rules,
-            dom_rules: dom_rules,
+            dom_rules: DOMRefCell::new(dom_rules),
         }
     }
 
@@ -40,12 +45,83 @@ impl CSSRuleList {
                            window,
                            CSSRuleListBinding::Wrap)
     }
+
+    // https://drafts.csswg.org/cssom/#insert-a-css-rule
+    pub fn insert_rule(&self, rule: &str, idx: u32) -> Fallible<u32> {
+        /// Insert an item into a vector, appending if it is out of bounds
+        fn insert<T>(vec: &mut Vec<T>, index: usize, item: T) {
+            if index >= vec.len() {
+                vec.push(item);
+            } else {
+                vec.insert(index, item);
+            }
+        }
+        let global = self.global();
+        let window = global.as_window();
+        let doc = window.Document();
+        let index = idx as usize;
+
+        // Step 1, 2
+        // XXXManishearth get url from correct location
+        // XXXManishearth should we also store the namespace map?
+        let new_rule = try!(StyleCssRule::from_str(&rule, Origin::Author,
+                                                   doc.url().clone(),
+                                                   ParserContextExtraData::default())
+                          .map_err(|_| Error::Syntax));
+
+        {
+            let rules = self.rules.0.read();
+            // Step 3, 4
+            if index > rules.len() {
+                return Err(Error::IndexSize);
+            }
+
+            // XXXManishearth Step 5 (throw HierarchyRequestError in invalid situations)
+
+            // Step 6
+            if let StyleCssRule::Namespace(..) = new_rule {
+                if !CssRules::only_ns_or_import(&rules) {
+                    return Err(Error::InvalidState);
+                }
+            }
+        }
+
+        insert(&mut self.rules.0.write(), index, new_rule.clone());
+        let dom_rule = CSSRule::new_specific(&window, &self.sheet, new_rule);
+        insert(&mut self.dom_rules.borrow_mut(),
+               index, MutNullableHeap::new(Some(&*dom_rule)));
+        Ok((idx))
+    }
+
+    // https://drafts.csswg.org/cssom/#remove-a-css-rule
+    pub fn remove_rule(&self, index: u32) -> ErrorResult {
+        let index = index as usize;
+
+        {
+            let rules = self.rules.0.read();
+            if index >= rules.len() {
+                return Err(Error::IndexSize);
+            }
+            let ref rule = rules[index];
+            if let StyleCssRule::Namespace(..) = *rule {
+                if !CssRules::only_ns_or_import(&rules) {
+                    return Err(Error::InvalidState);
+                }
+            }
+        }
+
+        let mut dom_rules = self.dom_rules.borrow_mut();
+        self.rules.0.write().remove(index);
+        dom_rules[index].get().map(|r| r.disown());
+        dom_rules.remove(index);
+        Ok(())
+    }
 }
 
 impl CSSRuleListMethods for CSSRuleList {
     // https://drafts.csswg.org/cssom/#ref-for-dom-cssrulelist-item-1
     fn Item(&self, idx: u32) -> Option<Root<CSSRule>> {
-        self.dom_rules.get(idx as usize).map(|rule| {
+        self.dom_rules.borrow().get(idx as usize).map(|rule| {
             rule.or_init(|| {
                 CSSRule::new_specific(self.global().as_window(),
                                      &self.sheet,
@@ -56,7 +132,7 @@ impl CSSRuleListMethods for CSSRuleList {
 
     // https://drafts.csswg.org/cssom/#dom-cssrulelist-length
     fn Length(&self) -> u32 {
-        self.dom_rules.len() as u32
+        self.dom_rules.borrow().len() as u32
     }
 
     // check-tidy: no specs after this line

components/script/dom/cssstylesheet.rs

@@ -4,6 +4,7 @@
 
 use dom::bindings::codegen::Bindings::CSSStyleSheetBinding;
 use dom::bindings::codegen::Bindings::CSSStyleSheetBinding::CSSStyleSheetMethods;
+use dom::bindings::error::{ErrorResult, Fallible};
 use dom::bindings::js::{JS, Root, MutNullableHeap};
 use dom::bindings::reflector::{reflect_dom_object, Reflectable};
 use dom::bindings::str::DOMString;
@@ -40,12 +41,31 @@ impl CSSStyleSheet {
                            window,
                            CSSStyleSheetBinding::Wrap)
     }
+
+    fn rulelist(&self) -> Root<CSSRuleList> {
+        self.rulelist.or_init(|| CSSRuleList::new(self.global().as_window(),
+                                                  self,
+                                                  self.style_stylesheet.rules.clone()))
+    }
 }
 
 impl CSSStyleSheetMethods for CSSStyleSheet {
     // https://drafts.csswg.org/cssom/#dom-cssstylesheet-cssrules
     fn CssRules(&self) -> Root<CSSRuleList> {
-        self.rulelist.or_init(|| CSSRuleList::new(self.global().as_window(), self, self.style_stylesheet.rules.clone()))
+        // XXXManishearth check origin clean flag
+        self.rulelist()
+    }
+
+    // https://drafts.csswg.org/cssom/#dom-cssstylesheet-insertrule
+    fn InsertRule(&self, rule: DOMString, index: u32) -> Fallible<u32> {
+        // XXXManishearth check origin clean flag
+        self.rulelist().insert_rule(&rule, index)
+    }
+
+    // https://drafts.csswg.org/cssom/#dom-cssstylesheet-deleterule
+    fn DeleteRule(&self, index: u32) -> ErrorResult {
+        // XXXManishearth check origin clean flag
+        self.rulelist().remove_rule(index)
     }
 }
 

components/script/dom/webidls/CSSStyleSheet.webidl

@@ -7,6 +7,6 @@
 interface CSSStyleSheet : StyleSheet {
   // readonly attribute CSSRule? ownerRule;
   [SameObject] readonly attribute CSSRuleList cssRules;
-  // unsigned long insertRule(DOMString rule, unsigned long index);
-  // void deleteRule(unsigned long index);
+  [Throws] unsigned long insertRule(DOMString rule, unsigned long index);
+  [Throws] void deleteRule(unsigned long index);
 };