1 files changed, 78 insertions, 27 deletions

diff --git a/components/script/dom/cssstylerule.rs b/components/script/dom/cssstylerule.rs
index fed2b947f90..a84c5c598b7 100644
--- a/components/script/dom/cssstylerule.rs
+++ b/components/script/dom/cssstylerule.rs
@@ -1,32 +1,40 @@
 /* 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/. */
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-use dom::bindings::codegen::Bindings::CSSStyleRuleBinding::{self, CSSStyleRuleMethods};
-use dom::bindings::inheritance::Castable;
-use dom::bindings::js::{JS, MutNullableJS, Root};
-use dom::bindings::reflector::{DomObject, reflect_dom_object};
-use dom::bindings::str::DOMString;
-use dom::cssrule::{CSSRule, SpecificCSSRule};
-use dom::cssstyledeclaration::{CSSModificationAccess, CSSStyleDeclaration, CSSStyleOwner};
-use dom::cssstylesheet::CSSStyleSheet;
-use dom::window::Window;
+use crate::dom::bindings::codegen::Bindings::CSSStyleRuleBinding::CSSStyleRuleMethods;
+use crate::dom::bindings::inheritance::Castable;
+use crate::dom::bindings::reflector::{reflect_dom_object, DomObject};
+use crate::dom::bindings::root::{Dom, DomRoot, MutNullableDom};
+use crate::dom::bindings::str::DOMString;
+use crate::dom::cssrule::{CSSRule, SpecificCSSRule};
+use crate::dom::cssstyledeclaration::{CSSModificationAccess, CSSStyleDeclaration, CSSStyleOwner};
+use crate::dom::cssstylesheet::CSSStyleSheet;
+use crate::dom::node::{stylesheets_owner_from_node, Node};
+use crate::dom::window::Window;
+use cssparser::ToCss;
+use cssparser::{Parser as CssParser, ParserInput as CssParserInput};
 use dom_struct::dom_struct;
-use std::sync::Arc;
+use selectors::parser::SelectorList;
+use servo_arc::Arc;
+use std::mem;
+use style::selector_parser::SelectorParser;
 use style::shared_lock::{Locked, ToCssWithGuard};
-use style::stylesheets::StyleRule;
+use style::stylesheets::{Origin, StyleRule};
 
 #[dom_struct]
 pub struct CSSStyleRule {
     cssrule: CSSRule,
-    #[ignore_heap_size_of = "Arc"]
+    #[ignore_malloc_size_of = "Arc"]
     stylerule: Arc<Locked<StyleRule>>,
-    style_decl: MutNullableJS<CSSStyleDeclaration>,
+    style_decl: MutNullableDom<CSSStyleDeclaration>,
 }
 
 impl CSSStyleRule {
-    fn new_inherited(parent_stylesheet: &CSSStyleSheet, stylerule: Arc<Locked<StyleRule>>)
-                     -> CSSStyleRule {
+    fn new_inherited(
+        parent_stylesheet: &CSSStyleSheet,
+        stylerule: Arc<Locked<StyleRule>>,
+    ) -> CSSStyleRule {
         CSSStyleRule {
             cssrule: CSSRule::new_inherited(parent_stylesheet),
             stylerule: stylerule,
@@ -35,40 +43,83 @@ impl CSSStyleRule {
     }
 
     #[allow(unrooted_must_root)]
-    pub fn new(window: &Window, parent_stylesheet: &CSSStyleSheet,
-               stylerule: Arc<Locked<StyleRule>>) -> Root<CSSStyleRule> {
-        reflect_dom_object(box CSSStyleRule::new_inherited(parent_stylesheet, stylerule),
-                           window,
-                           CSSStyleRuleBinding::Wrap)
+    pub fn new(
+        window: &Window,
+        parent_stylesheet: &CSSStyleSheet,
+        stylerule: Arc<Locked<StyleRule>>,
+    ) -> DomRoot<CSSStyleRule> {
+        reflect_dom_object(
+            Box::new(CSSStyleRule::new_inherited(parent_stylesheet, stylerule)),
+            window,
+        )
     }
 }
 
 impl SpecificCSSRule for CSSStyleRule {
     fn ty(&self) -> u16 {
-        use dom::bindings::codegen::Bindings::CSSRuleBinding::CSSRuleConstants;
+        use crate::dom::bindings::codegen::Bindings::CSSRuleBinding::CSSRuleConstants;
         CSSRuleConstants::STYLE_RULE
     }
 
     fn get_css(&self) -> DOMString {
         let guard = self.cssrule.shared_lock().read();
-        self.stylerule.read_with(&guard).to_css_string(&guard).into()
+        self.stylerule
+            .read_with(&guard)
+            .to_css_string(&guard)
+            .into()
     }
 }
 
 impl CSSStyleRuleMethods for CSSStyleRule {
     // https://drafts.csswg.org/cssom/#dom-cssstylerule-style
-    fn Style(&self) -> Root<CSSStyleDeclaration> {
+    fn Style(&self) -> DomRoot<CSSStyleDeclaration> {
         self.style_decl.or_init(|| {
             let guard = self.cssrule.shared_lock().read();
             CSSStyleDeclaration::new(
                 self.global().as_window(),
                 CSSStyleOwner::CSSRule(
-                    JS::from_ref(self.upcast()),
-                    self.stylerule.read_with(&guard).block.clone()
+                    Dom::from_ref(self.upcast()),
+                    self.stylerule.read_with(&guard).block.clone(),
                 ),
                 None,
-                CSSModificationAccess::ReadWrite
+                CSSModificationAccess::ReadWrite,
             )
         })
     }
+
+    // https://drafts.csswg.org/cssom/#dom-cssstylerule-selectortext
+    fn SelectorText(&self) -> DOMString {
+        let guard = self.cssrule.shared_lock().read();
+        let stylerule = self.stylerule.read_with(&guard);
+        return DOMString::from_string(stylerule.selectors.to_css_string());
+    }
+
+    // https://drafts.csswg.org/cssom/#dom-cssstylerule-selectortext
+    fn SetSelectorText(&self, value: DOMString) {
+        // It's not clear from the spec if we should use the stylesheet's namespaces.
+        // https://github.com/w3c/csswg-drafts/issues/1511
+        let namespaces = self
+            .cssrule
+            .parent_stylesheet()
+            .style_stylesheet()
+            .contents
+            .namespaces
+            .read();
+        let parser = SelectorParser {
+            stylesheet_origin: Origin::Author,
+            namespaces: &namespaces,
+            url_data: None,
+        };
+        let mut css_parser = CssParserInput::new(&*value);
+        let mut css_parser = CssParser::new(&mut css_parser);
+        if let Ok(mut s) = SelectorList::parse(&parser, &mut css_parser) {
+            // This mirrors what we do in CSSStyleOwner::mutate_associated_block.
+            let mut guard = self.cssrule.shared_lock().write();
+            let stylerule = self.stylerule.write_with(&mut guard);
+            mem::swap(&mut stylerule.selectors, &mut s);
+            if let Some(owner) = self.cssrule.parent_stylesheet().get_owner() {
+                stylesheets_owner_from_node(owner.upcast::<Node>()).invalidate_stylesheets();
+            }
+        }
+    }
 }