Make parent stylesheet optional for CSSRules

servo · Nov 23, 2016 · 53c9966 · 53c9966
1 parent 52a3a71
commit 53c9966
Show file tree

Hide file tree

Showing 11 changed files with 41 additions and 32 deletions.
diff --git a/components/script/dom/cssfontfacerule.rs b/components/script/dom/cssfontfacerule.rs
@@ -22,15 +22,15 @@ pub struct CSSFontFaceRule {
 }
 
 impl CSSFontFaceRule {
-    fn new_inherited(parent: &CSSStyleSheet, fontfacerule: Arc<RwLock<FontFaceRule>>) -> CSSFontFaceRule {
+    fn new_inherited(parent: Option<&CSSStyleSheet>, fontfacerule: Arc<RwLock<FontFaceRule>>) -> CSSFontFaceRule {
         CSSFontFaceRule {
             cssrule: CSSRule::new_inherited(parent),
             fontfacerule: fontfacerule,
         }
     }
 
     #[allow(unrooted_must_root)]
-    pub fn new(window: &Window, parent: &CSSStyleSheet,
+    pub fn new(window: &Window, parent: Option<&CSSStyleSheet>,
                fontfacerule: Arc<RwLock<FontFaceRule>>) -> Root<CSSFontFaceRule> {
         reflect_dom_object(box CSSFontFaceRule::new_inherited(parent, fontfacerule),
                            window,

diff --git a/components/script/dom/cssgroupingrule.rs b/components/script/dom/cssgroupingrule.rs
@@ -15,14 +15,14 @@ pub struct CSSGroupingRule {
 }
 
 impl CSSGroupingRule {
-    pub fn new_inherited(parent: &CSSStyleSheet) -> CSSGroupingRule {
+    pub fn new_inherited(parent: Option<&CSSStyleSheet>) -> CSSGroupingRule {
         CSSGroupingRule {
             cssrule: CSSRule::new_inherited(parent),
         }
     }
 
     #[allow(unrooted_must_root)]
-    pub fn new(window: &Window, parent: &CSSStyleSheet) -> Root<CSSGroupingRule> {
+    pub fn new(window: &Window, parent: Option<&CSSStyleSheet>) -> Root<CSSGroupingRule> {
         reflect_dom_object(box CSSGroupingRule::new_inherited(parent),
                            window,
                            CSSGroupingRuleBinding::Wrap)

diff --git a/components/script/dom/csskeyframerule.rs b/components/script/dom/csskeyframerule.rs
@@ -21,15 +21,15 @@ pub struct CSSKeyframeRule {
 }
 
 impl CSSKeyframeRule {
-    fn new_inherited(parent: &CSSStyleSheet, keyframerule: Arc<RwLock<Keyframe>>) -> CSSKeyframeRule {
+    fn new_inherited(parent: Option<&CSSStyleSheet>, keyframerule: Arc<RwLock<Keyframe>>) -> CSSKeyframeRule {
         CSSKeyframeRule {
             cssrule: CSSRule::new_inherited(parent),
             keyframerule: keyframerule,
         }
     }
 
     #[allow(unrooted_must_root)]
-    pub fn new(window: &Window, parent: &CSSStyleSheet,
+    pub fn new(window: &Window, parent: Option<&CSSStyleSheet>,
                keyframerule: Arc<RwLock<Keyframe>>) -> Root<CSSKeyframeRule> {
         reflect_dom_object(box CSSKeyframeRule::new_inherited(parent, keyframerule),
                            window,

diff --git a/components/script/dom/csskeyframesrule.rs b/components/script/dom/csskeyframesrule.rs
@@ -27,7 +27,7 @@ pub struct CSSKeyframesRule {
 }
 
 impl CSSKeyframesRule {
-    fn new_inherited(parent: &CSSStyleSheet, keyframesrule: Arc<RwLock<KeyframesRule>>) -> CSSKeyframesRule {
+    fn new_inherited(parent: Option<&CSSStyleSheet>, keyframesrule: Arc<RwLock<KeyframesRule>>) -> CSSKeyframesRule {
         CSSKeyframesRule {
             cssrule: CSSRule::new_inherited(parent),
             keyframesrule: keyframesrule,
@@ -36,18 +36,21 @@ impl CSSKeyframesRule {
     }
 
     #[allow(unrooted_must_root)]
-    pub fn new(window: &Window, parent: &CSSStyleSheet,
+    pub fn new(window: &Window, parent: Option<&CSSStyleSheet>,
                keyframesrule: Arc<RwLock<KeyframesRule>>) -> Root<CSSKeyframesRule> {
         reflect_dom_object(box CSSKeyframesRule::new_inherited(parent, keyframesrule),
                            window,
                            CSSKeyframesRuleBinding::Wrap)
     }
 
     fn rulelist(&self) -> Root<CSSRuleList> {
-        self.rulelist.or_init(|| CSSRuleList::new(self.global().as_window(),
-                                                  // temporary unwrap
-                                                  &self.upcast::<CSSRule>().GetParentStyleSheet().unwrap(),
-                                                  RulesSource::Keyframes(self.keyframesrule.clone())))
+        self.rulelist.or_init(|| {
+            let sheet = self.upcast::<CSSRule>().GetParentStyleSheet();
+            let sheet = sheet.as_ref().map(|s| &**s);
+            CSSRuleList::new(self.global().as_window(),
+                             sheet,
+                             RulesSource::Keyframes(self.keyframesrule.clone()))
+        })
     }
 }
 

diff --git a/components/script/dom/cssmediarule.rs b/components/script/dom/cssmediarule.rs
@@ -23,15 +23,15 @@ pub struct CSSMediaRule {
 }
 
 impl CSSMediaRule {
-    fn new_inherited(parent: &CSSStyleSheet, mediarule: Arc<RwLock<MediaRule>>) -> CSSMediaRule {
+    fn new_inherited(parent: Option<&CSSStyleSheet>, mediarule: Arc<RwLock<MediaRule>>) -> CSSMediaRule {
         CSSMediaRule {
             cssrule: CSSGroupingRule::new_inherited(parent),
             mediarule: mediarule,
         }
     }
 
     #[allow(unrooted_must_root)]
-    pub fn new(window: &Window, parent: &CSSStyleSheet,
+    pub fn new(window: &Window, parent: Option<&CSSStyleSheet>,
                mediarule: Arc<RwLock<MediaRule>>) -> Root<CSSMediaRule> {
         reflect_dom_object(box CSSMediaRule::new_inherited(parent, mediarule),
                            window,

diff --git a/components/script/dom/cssnamespacerule.rs b/components/script/dom/cssnamespacerule.rs
@@ -22,15 +22,15 @@ pub struct CSSNamespaceRule {
 }
 
 impl CSSNamespaceRule {
-    fn new_inherited(parent: &CSSStyleSheet, namespacerule: Arc<RwLock<NamespaceRule>>) -> CSSNamespaceRule {
+    fn new_inherited(parent: Option<&CSSStyleSheet>, namespacerule: Arc<RwLock<NamespaceRule>>) -> CSSNamespaceRule {
         CSSNamespaceRule {
             cssrule: CSSRule::new_inherited(parent),
             namespacerule: namespacerule,
         }
     }
 
     #[allow(unrooted_must_root)]
-    pub fn new(window: &Window, parent: &CSSStyleSheet,
+    pub fn new(window: &Window, parent: Option<&CSSStyleSheet>,
                namespacerule: Arc<RwLock<NamespaceRule>>) -> Root<CSSNamespaceRule> {
         reflect_dom_object(box CSSNamespaceRule::new_inherited(parent, namespacerule),
                            window,

diff --git a/components/script/dom/cssrule.rs b/components/script/dom/cssrule.rs
@@ -28,15 +28,15 @@ pub struct CSSRule {
 
 impl CSSRule {
     #[allow(unrooted_must_root)]
-    pub fn new_inherited(parent: &CSSStyleSheet) -> CSSRule {
+    pub fn new_inherited(parent: Option<&CSSStyleSheet>) -> CSSRule {
         CSSRule {
             reflector_: Reflector::new(),
-            parent: MutNullableHeap::new(Some(parent)),
+            parent: MutNullableHeap::new(parent),
         }
     }
 
     #[allow(unrooted_must_root)]
-    pub fn new(window: &Window, parent: &CSSStyleSheet) -> Root<CSSRule> {
+    pub fn new(window: &Window, parent: Option<&CSSStyleSheet>) -> Root<CSSRule> {
         reflect_dom_object(box CSSRule::new_inherited(parent),
                            window,
                            CSSRuleBinding::Wrap)
@@ -64,7 +64,7 @@ impl CSSRule {
 
     // Given a StyleCssRule, create a new instance of a derived class of
     // CSSRule based on which rule it is
-    pub fn new_specific(window: &Window, parent: &CSSStyleSheet,
+    pub fn new_specific(window: &Window, parent: Option<&CSSStyleSheet>,
                         rule: StyleCssRule) -> Root<CSSRule> {
         // be sure to update the match in as_specific when this is updated
         match rule {
@@ -81,6 +81,7 @@ impl CSSRule {
     pub fn disown(&self) {
         self.parent.set(None);
         // should set parent rule to None when we add parent rule support
+        // Should we disown children as well? (https://github.com/w3c/csswg-drafts/issues/722)
     }
 }
 

diff --git a/components/script/dom/cssrulelist.rs b/components/script/dom/cssrulelist.rs
@@ -24,7 +24,7 @@ no_jsmanaged_fields!(RulesSource);
 #[dom_struct]
 pub struct CSSRuleList {
     reflector_: Reflector,
-    sheet: JS<CSSStyleSheet>,
+    sheet: MutNullableHeap<JS<CSSStyleSheet>>,
     #[ignore_heap_size_of = "Arc"]
     rules: RulesSource,
     dom_rules: DOMRefCell<Vec<MutNullableHeap<JS<CSSRule>>>>
@@ -37,7 +37,7 @@ pub enum RulesSource {
 
 impl CSSRuleList {
     #[allow(unrooted_must_root)]
-    pub fn new_inherited(sheet: &CSSStyleSheet, rules: RulesSource) -> CSSRuleList {
+    pub fn new_inherited(sheet: Option<&CSSStyleSheet>, rules: RulesSource) -> CSSRuleList {
         let dom_rules = match rules {
             RulesSource::Rules(ref rules) => {
                 rules.0.read().iter().map(|_| MutNullableHeap::new(None)).collect()
@@ -49,14 +49,15 @@ impl CSSRuleList {
 
         CSSRuleList {
             reflector_: Reflector::new(),
-            sheet: JS::from_ref(sheet),
+            sheet: MutNullableHeap::new(sheet),
             rules: rules,
             dom_rules: DOMRefCell::new(dom_rules),
         }
     }
 
     #[allow(unrooted_must_root)]
-    pub fn new(window: &Window, sheet: &CSSStyleSheet, rules: RulesSource) -> Root<CSSRuleList> {
+    pub fn new(window: &Window, sheet: Option<&CSSStyleSheet>,
+               rules: RulesSource) -> Root<CSSRuleList> {
         reflect_dom_object(box CSSRuleList::new_inherited(sheet, rules),
                            window,
                            CSSRuleListBinding::Wrap)
@@ -132,7 +133,9 @@ impl CSSRuleList {
         };
 
         insert(&mut css_rules.0.write(), index, new_rule.clone());
-        let dom_rule = CSSRule::new_specific(&window, &self.sheet, new_rule);
+        let sheet = self.sheet.get();
+        let sheet = sheet.as_ref().map(|sheet| &**sheet);
+        let dom_rule = CSSRule::new_specific(&window, sheet, new_rule);
         insert(&mut self.dom_rules.borrow_mut(),
                index, MutNullableHeap::new(Some(&*dom_rule)));
         Ok((idx))
@@ -174,15 +177,17 @@ impl CSSRuleListMethods for CSSRuleList {
     fn Item(&self, idx: u32) -> Option<Root<CSSRule>> {
         self.dom_rules.borrow().get(idx as usize).map(|rule| {
             rule.or_init(|| {
+                let sheet = self.sheet.get();
+                let sheet = sheet.as_ref().map(|sheet| &**sheet);
                 match self.rules {
                     RulesSource::Rules(ref rules) => {
                         CSSRule::new_specific(self.global().as_window(),
-                                             &self.sheet,
+                                             sheet,
                                              rules.0.read()[idx as usize].clone())
                     }
                     RulesSource::Keyframes(ref rules) => {
                         Root::upcast(CSSKeyframeRule::new(self.global().as_window(),
-                                                          &self.sheet,
+                                                          sheet,
                                                           rules.read()
                                                                 .keyframes[idx as usize]
                                                                 .clone()))

diff --git a/components/script/dom/cssstylerule.rs b/components/script/dom/cssstylerule.rs
@@ -22,15 +22,15 @@ pub struct CSSStyleRule {
 }
 
 impl CSSStyleRule {
-    fn new_inherited(parent: &CSSStyleSheet, stylerule: Arc<RwLock<StyleRule>>) -> CSSStyleRule {
+    fn new_inherited(parent: Option<&CSSStyleSheet>, stylerule: Arc<RwLock<StyleRule>>) -> CSSStyleRule {
         CSSStyleRule {
             cssrule: CSSRule::new_inherited(parent),
             stylerule: stylerule,
         }
     }
 
     #[allow(unrooted_must_root)]
-    pub fn new(window: &Window, parent: &CSSStyleSheet,
+    pub fn new(window: &Window, parent: Option<&CSSStyleSheet>,
                stylerule: Arc<RwLock<StyleRule>>) -> Root<CSSStyleRule> {
         reflect_dom_object(box CSSStyleRule::new_inherited(parent, stylerule),
                            window,

diff --git a/components/script/dom/cssstylesheet.rs b/components/script/dom/cssstylesheet.rs
@@ -44,7 +44,7 @@ impl CSSStyleSheet {
 
     fn rulelist(&self) -> Root<CSSRuleList> {
         self.rulelist.or_init(|| CSSRuleList::new(self.global().as_window(),
-                                                  self,
+                                                  Some(self),
                                                   RulesSource::Rules(self.style_stylesheet
                                                                          .rules.clone())))
     }

diff --git a/components/script/dom/cssviewportrule.rs b/components/script/dom/cssviewportrule.rs
@@ -22,15 +22,15 @@ pub struct CSSViewportRule {
 }
 
 impl CSSViewportRule {
-    fn new_inherited(parent: &CSSStyleSheet, viewportrule: Arc<RwLock<ViewportRule>>) -> CSSViewportRule {
+    fn new_inherited(parent: Option<&CSSStyleSheet>, viewportrule: Arc<RwLock<ViewportRule>>) -> CSSViewportRule {
         CSSViewportRule {
             cssrule: CSSRule::new_inherited(parent),
             viewportrule: viewportrule,
         }
     }
 
     #[allow(unrooted_must_root)]
-    pub fn new(window: &Window, parent: &CSSStyleSheet,
+    pub fn new(window: &Window, parent: Option<&CSSStyleSheet>,
                viewportrule: Arc<RwLock<ViewportRule>>) -> Root<CSSViewportRule> {
         reflect_dom_object(box CSSViewportRule::new_inherited(parent, viewportrule),
                            window,