DevTools: kill WebInspector.SectionCascade class

third_party/WebKit/Source/devtools/front_end/elements/StylesSidebarPane.js

 /*
  * Copyright (C) 2007 Apple Inc.  All rights reserved.
  * Copyright (C) 2009 Joseph Pecoraro
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 294 matching lines @@
         return this.fetchMatchedCascade()
             .then(this._innerRebuildUpdate.bind(this));
     },
 
     _resetCache: function()
     {
         delete this._matchedCascadePromise;
     },
 
     /**
-     * @return {!Promise.<?{matched: !WebInspector.SectionCascade, pseudo: !Map.<number, !WebInspector.SectionCascade>}>}
+     * @return {!Promise.<?WebInspector.CSSStyleModel.MatchedStyleResult>}
      */
     fetchMatchedCascade: function()
     {
         var node = this.node();
         if (!node)
-            return Promise.resolve(/** @type {?{matched: !WebInspector.SectionCascade, pseudo: !Map.<number, !WebInspector.SectionCascade>}} */(null));
+            return Promise.resolve(/** @type {?WebInspector.CSSStyleModel.MatchedStyleResult} */(null));
         if (!this._matchedCascadePromise)
-            this._matchedCascadePromise = this._matchedStylesForNode(node).then(buildMatchedCascades.bind(this, node));
+            this._matchedCascadePromise = this._matchedStylesForNode(node).then(validateStyles.bind(this));
         return this._matchedCascadePromise;
 
         /**
-         * @param {!WebInspector.DOMNode} node
          * @param {?WebInspector.CSSStyleModel.MatchedStyleResult} matchedStyles
-         * @return {?{matched: !WebInspector.SectionCascade, pseudo: !Map.<number, !WebInspector.SectionCascade>}}
+         * @return {?WebInspector.CSSStyleModel.MatchedStyleResult}
          * @this {WebInspector.StylesSidebarPane}
          */
-        function buildMatchedCascades(node, matchedStyles)
+        function validateStyles(matchedStyles)
         {
-            if (!matchedStyles || node !== this.node())
-                return null;
-
-            return WebInspector.SectionCascade.fromMatchedStyles(matchedStyles);
+            return matchedStyles && matchedStyles.node() === this.node() ? matchedStyles : null;
         }
     },
 
     /**
      * @param {!WebInspector.DOMNode} node
      * @return {!Promise.<?WebInspector.CSSStyleModel.MatchedStyleResult>}
      */
     _matchedStylesForNode: function(node)
     {
         var cssModel = this.cssModel();
@@ skipping 54 matching lines @@
     /**
      * @param {?WebInspector.DOMNode} node
      */
     _canAffectCurrentStyles: function(node)
     {
         var currentNode = this.node();
         return currentNode && (currentNode === node || node.parentNode === currentNode.parentNode || node.isAncestor(currentNode));
     },
 
     /**
-     * @param {?{matched: !WebInspector.SectionCascade, pseudo: !Map.<number, !WebInspector.SectionCascade>}} cascades
+     * @param {?WebInspector.CSSStyleModel.MatchedStyleResult} matchedStyles
      */
-    _innerRebuildUpdate: function(cascades)
+    _innerRebuildUpdate: function(matchedStyles)
     {
         this._linkifier.reset();
         this._sectionsContainer.removeChildren();
         this._sectionBlocks = [];
 
         var node = this.node();
-        if (!cascades || !node)
+        if (!matchedStyles || !node)
             return;
 
-        this._sectionBlocks = this._rebuildSectionsForMatchedStyleRules(cascades.matched);
+        this._sectionBlocks = this._rebuildSectionsForMatchedStyleRules(matchedStyles);
         var pseudoTypes = [];
-        var keys = new Set(cascades.pseudo.keys());
+        var keys = new Set(matchedStyles.pseudoStyles().keys());
         if (keys.delete(DOMAgent.PseudoType.Before))
             pseudoTypes.push(DOMAgent.PseudoType.Before);
         pseudoTypes = pseudoTypes.concat(keys.valuesArray().sort());
         for (var pseudoType of pseudoTypes) {
             var block = WebInspector.SectionBlock.createPseudoTypeBlock(pseudoType);
-            var cascade = cascades.pseudo.get(pseudoType);
-            for (var style of cascade.styles()) {
-                var section = new WebInspector.StylePropertiesSection(this, cascade, style);
+            var styles = /** @type {!Array<!WebInspector.CSSStyleDeclaration>} */(matchedStyles.pseudoStyles().get(pseudoType));
+            for (var style of styles) {
+                var section = new WebInspector.StylePropertiesSection(this, matchedStyles, style);
                 block.sections.push(section);
             }
             this._sectionBlocks.push(block);
         }
 
         for (var block of this._sectionBlocks) {
             var titleElement = block.titleElement();
             if (titleElement)
                 this._sectionsContainer.appendChild(titleElement);
             for (var section of block.sections)
                 this._sectionsContainer.appendChild(section.element);
         }
 
         if (this._filterRegex)
             this._updateFilter();
 
         this._nodeStylesUpdatedForTest(node, true);
     },
 
     /**
      * @param {!WebInspector.DOMNode} node
      * @param {boolean} rebuild
      */
     _nodeStylesUpdatedForTest: function(node, rebuild)
     {
         // For sniffing in tests.
     },
 
     /**
-     * @param {!WebInspector.SectionCascade} matchedCascade
+     * @param {!WebInspector.CSSStyleModel.MatchedStyleResult} matchedStyles
      * @return {!Array.<!WebInspector.SectionBlock>}
      */
-    _rebuildSectionsForMatchedStyleRules: function(matchedCascade)
+    _rebuildSectionsForMatchedStyleRules: function(matchedStyles)
     {
         var blocks = [new WebInspector.SectionBlock(null)];
         var lastParentNode = null;
-        for (var style of matchedCascade.styles()) {
-            var parentNode = matchedCascade.isInherited(style) ? matchedCascade.nodeForStyle(style) : null;
+        for (var style of matchedStyles.nodeStyles()) {
+            var parentNode = matchedStyles.isInherited(style) ? matchedStyles.nodeForStyle(style) : null;
             if (parentNode && parentNode !== lastParentNode) {
                 lastParentNode = parentNode;
                 var block = WebInspector.SectionBlock.createInheritedNodeBlock(lastParentNode);
                 blocks.push(block);
             }
 
-            var section = new WebInspector.StylePropertiesSection(this, matchedCascade, style);
+            var section = new WebInspector.StylePropertiesSection(this, matchedStyles, style);
             blocks.peekLast().sections.push(section);
         }
         return blocks;
     },
 
     _createNewRuleInViaInspectorStyleSheet: function()
     {
         var cssModel = this.cssModel();
         var node = this.node();
         if (!cssModel || !node)
@@ skipping 36 matching lines @@
 
     /**
      * @param {!WebInspector.StylePropertiesSection} insertAfterSection
      * @param {string} styleSheetId
      * @param {!WebInspector.TextRange} ruleLocation
      */
     _addBlankSection: function(insertAfterSection, styleSheetId, ruleLocation)
     {
         this.expand();
         var node = this.node();
-        var blankSection = new WebInspector.BlankStylePropertiesSection(this, insertAfterSection._cascade, node ? WebInspector.DOMPresentationUtils.simpleSelector(node) : "", styleSheetId, ruleLocation, insertAfterSection._style);
+        var blankSection = new WebInspector.BlankStylePropertiesSection(this, insertAfterSection._matchedStyles, node ? WebInspector.DOMPresentationUtils.simpleSelector(node) : "", styleSheetId, ruleLocation, insertAfterSection._style);
 
         this._sectionsContainer.insertBefore(blankSection.element, insertAfterSection.element.nextSibling);
 
         for (var block of this._sectionBlocks) {
             var index = block.sections.indexOf(insertAfterSection);
             if (index === -1)
                 continue;
             block.sections.splice(index + 1, 0, blankSection);
             blankSection.startEditingSelector();
         }
@@ skipping 201 matching lines @@
      */
     titleElement: function()
     {
         return this._titleElement;
     }
 }
 
 /**
  * @constructor
  * @param {!WebInspector.StylesSidebarPane} parentPane
- * @param {!WebInspector.SectionCascade} cascade
+ * @param {!WebInspector.CSSStyleModel.MatchedStyleResult} matchedStyles
  * @param {!WebInspector.CSSStyleDeclaration} style
  */
-WebInspector.StylePropertiesSection = function(parentPane, cascade, style)
+WebInspector.StylePropertiesSection = function(parentPane, matchedStyles, style)
 {
     this._parentPane = parentPane;
     this._style = style;
-    this._cascade = cascade;
+    this._matchedStyles = matchedStyles;
     this.editable = !!(style.styleSheetId && style.range);
 
     var rule = style.parentRule;
     this.element = createElementWithClass("div", "styles-section matched-styles monospace");
     this.element._section = this;
 
     this._titleElement = this.element.createChild("div", "styles-section-title " + (rule ? "styles-selector" : ""));
 
     this.propertiesTreeOutline = new TreeOutline();
     this.propertiesTreeOutline.element.classList.add("style-properties", "monospace");
@@ skipping 99 matching lines @@
     style: function()
     {
         return this._style;
     },
 
     /**
      * @return {string}
      */
     _selectorText: function()
     {
-        var node = this._cascade.nodeForStyle(this._style);
+        var node = this._matchedStyles.nodeForStyle(this._style);
         if (this._style.type === WebInspector.CSSStyleDeclaration.Type.Inline)
-            return this._cascade.isInherited(this._style) ? WebInspector.UIString("Style Attribute") : "element.style";
+            return this._matchedStyles.isInherited(this._style) ? WebInspector.UIString("Style Attribute") : "element.style";
         if (this._style.type === WebInspector.CSSStyleDeclaration.Type.Attributes)
             return node.nodeNameInCorrectCase() + "[" + WebInspector.UIString("Attributes Style") + "]";
         return this._style.parentRule.selectorText();
     },
 
     _onMouseOutSelector: function()
     {
         if (this._hoverTimer)
             clearTimeout(this._hoverTimer);
         WebInspector.DOMModel.hideDOMNodeHighlight()
@@ skipping 197 matching lines @@
         this._mediaListElement.removeChildren();
         this._createMediaList(this._style.parentRule ? this._style.parentRule.media : null);
     },
 
     /**
      * @param {string} propertyName
      * @return {boolean}
      */
     isPropertyInherited: function(propertyName)
     {
-        if (this._cascade.isInherited(this._style)) {
+        if (this._matchedStyles.isInherited(this._style)) {
             // While rendering inherited stylesheet, reverse meaning of this property.
             // Render truly inherited properties with black, i.e. return them as non-inherited.
             return !WebInspector.CSSMetadata.isPropertyInherited(propertyName);
         }
         return false;
     },
 
     /**
      * @return {?WebInspector.StylePropertiesSection}
      */
@@ skipping 38 matching lines @@
     update: function(full)
     {
         this._selectorElement.textContent = this._selectorText();
         this._markSelectorMatches();
         if (full) {
             this.propertiesTreeOutline.removeChildren();
             this.onpopulate();
         } else {
             var child = this.propertiesTreeOutline.firstChild();
             while (child) {
-                var overloaded = this._cascade.propertyState(child.property) === WebInspector.SectionCascade.PropertyState.Overloaded;
+                var overloaded = this._matchedStyles.propertyState(child.property) === WebInspector.CSSStyleModel.MatchedStyleResult.PropertyState.Overloaded;
                 child.setOverloaded(overloaded);
                 child = child.traverseNextTreeElement(false, null, true);
             }
         }
         this.afterUpdate();
     },
 
     afterUpdate: function()
     {
         if (this._afterUpdate) {
             this._afterUpdate(this);
             delete this._afterUpdate;
             this._afterUpdateFinishedForTest();
         }
     },
 
     _afterUpdateFinishedForTest: function()
     {
     },
 
     onpopulate: function()
     {
         var style = this._style;
         for (var property of style.leadingProperties()) {
             var isShorthand = !!WebInspector.CSSMetadata.cssPropertiesMetainfo.longhands(property.name);
             var inherited = this.isPropertyInherited(property.name);
-            var overloaded = this._cascade.propertyState(property) === WebInspector.SectionCascade.PropertyState.Overloaded;
-            var item = new WebInspector.StylePropertyTreeElement(this._parentPane, this._cascade, property, isShorthand, inherited, overloaded);
+            var overloaded = this._matchedStyles.propertyState(property) === WebInspector.CSSStyleModel.MatchedStyleResult.PropertyState.Overloaded;
+            var item = new WebInspector.StylePropertyTreeElement(this._parentPane, this._matchedStyles, property, isShorthand, inherited, overloaded);
             this.propertiesTreeOutline.appendChild(item);
         }
     },
 
     /**
      * @return {boolean}
      */
     _updateFilter: function()
     {
         var hasMatchingChild = false;
         for (var child of this.propertiesTreeOutline.rootElement().children())
             hasMatchingChild |= child._updateFilter();
 
         var regex = this._parentPane.filterRegex();
         var hideRule = !hasMatchingChild && regex && !regex.test(this.element.textContent);
         this.element.classList.toggle("hidden", hideRule);
         if (!hideRule && this._style.parentRule)
             this._markSelectorHighlights();
         return !hideRule;
     },
 
     _markSelectorMatches: function()
     {
         var rule = this._style.parentRule;
         if (!rule)
             return;
 
-        this._mediaListElement.classList.toggle("media-matches", this._cascade.mediaMatches(this._style));
+        this._mediaListElement.classList.toggle("media-matches", this._matchedStyles.mediaMatches(this._style));
 
-        if (!this._cascade.hasMatchingSelectors(this._style))
+        if (!this._matchedStyles.hasMatchingSelectors(this._style))
             return;
 
         var selectors = rule.selectors;
         var fragment = createDocumentFragment();
         var currentMatch = 0;
         var matchingSelectors = rule.matchingSelectors;
         for (var i = 0; i < selectors.length ; ++i) {
             if (i)
                 fragment.createTextChild(", ");
             var isSelectorMatching = matchingSelectors[currentMatch] === i;
@@ skipping 47 matching lines @@
         }
     },
 
     /**
      * @param {number=} index
      * @return {!WebInspector.StylePropertyTreeElement}
      */
     addNewBlankProperty: function(index)
     {
         var property = this._style.newBlankProperty(index);
-        var item = new WebInspector.StylePropertyTreeElement(this._parentPane, this._cascade, property, false, false, false);
+        var item = new WebInspector.StylePropertyTreeElement(this._parentPane, this._matchedStyles, property, false, false, false);
         index = property.index;
         this.propertiesTreeOutline.insertChild(item, index);
         item.listItemElement.textContent = "";
         item._newProperty = true;
         item.updateTitle();
         return item;
     },
 
     _handleEmptySpaceMouseDown: function()
     {
@@ skipping 249 matching lines @@
          * @param {!WebInspector.TextRange} oldSelectorRange
          * @param {boolean} success
          * @this {WebInspector.StylePropertiesSection}
          */
         function finishCallback(rule, oldSelectorRange, success)
         {
             if (success) {
                 var doesAffectSelectedNode = rule.matchingSelectors.length > 0;
                 this.element.classList.toggle("no-affect", !doesAffectSelectedNode);
 
-                this._cascade.resetActiveProperties();
+                this._matchedStyles.resetActiveProperties();
                 var newSelectorRange = /** @type {!WebInspector.TextRange} */(rule.selectorRange());
                 rule.style.sourceStyleSheetEdited(/** @type {string} */(rule.styleSheetId), oldSelectorRange, newSelectorRange);
                 this._parentPane._styleSheetRuleEdited(rule, oldSelectorRange, newSelectorRange);
                 this._parentPane._refreshUpdate(this);
             }
 
             delete this._parentPane._userOperation;
             this._moveEditorFromSelector(moveDirection);
             this._editingSelectorCommittedForTest();
         }
@@ skipping 76 matching lines @@
     var lineNumber = styleSheetHeader.lineNumberInSource(ruleLocation.startLine);
     var columnNumber = styleSheetHeader.columnNumberInSource(ruleLocation.startLine, ruleLocation.startColumn);
     var matchingSelectorLocation = new WebInspector.CSSLocation(cssModel, styleSheetId, sourceURL, lineNumber, columnNumber);
     return linkifier.linkifyCSSLocation(matchingSelectorLocation);
 }
 
 /**
  * @constructor
  * @extends {WebInspector.StylePropertiesSection}
  * @param {!WebInspector.StylesSidebarPane} stylesPane
- * @param {!WebInspector.SectionCascade} cascade
+ * @param {!WebInspector.CSSStyleModel.MatchedStyleResult} matchedStyles
  * @param {string} defaultSelectorText
  * @param {string} styleSheetId
  * @param {!WebInspector.TextRange} ruleLocation
  * @param {!WebInspector.CSSStyleDeclaration} insertAfterStyle
  */
-WebInspector.BlankStylePropertiesSection = function(stylesPane, cascade, defaultSelectorText, styleSheetId, ruleLocation, insertAfterStyle)
+WebInspector.BlankStylePropertiesSection = function(stylesPane, matchedStyles, defaultSelectorText, styleSheetId, ruleLocation, insertAfterStyle)
 {
     var rule = WebInspector.CSSRule.createDummyRule(stylesPane._cssModel, defaultSelectorText);
-    WebInspector.StylePropertiesSection.call(this, stylesPane, cascade, rule.style);
+    WebInspector.StylePropertiesSection.call(this, stylesPane, matchedStyles, rule.style);
     this._ruleLocation = ruleLocation;
     this._styleSheetId = styleSheetId;
     this._selectorRefElement.removeChildren();
     this._selectorRefElement.appendChild(WebInspector.StylePropertiesSection._linkifyRuleLocation(this._parentPane._cssModel, this._parentPane._linkifier, styleSheetId, this._actualRuleLocation()));
     if (insertAfterStyle && insertAfterStyle.parentRule)
         this._createMediaList(insertAfterStyle.parentRule.media);
     this.element.classList.add("blank-section");
 }
 
 WebInspector.BlankStylePropertiesSection.prototype = {
@@ skipping 105 matching lines @@
         this._normal = true;
     },
 
     __proto__: WebInspector.StylePropertiesSection.prototype
 }
 
 /**
  * @constructor
  * @extends {TreeElement}
  * @param {!WebInspector.StylesSidebarPane} stylesPane
- * @param {!WebInspector.SectionCascade} cascade
+ * @param {!WebInspector.CSSStyleModel.MatchedStyleResult} matchedStyles
  * @param {!WebInspector.CSSProperty} property
  * @param {boolean} isShorthand
  * @param {boolean} inherited
  * @param {boolean} overloaded
  */
-WebInspector.StylePropertyTreeElement = function(stylesPane, cascade, property, isShorthand, inherited, overloaded)
+WebInspector.StylePropertyTreeElement = function(stylesPane, matchedStyles, property, isShorthand, inherited, overloaded)
 {
     // Pass an empty title, the title gets made later in onattach.
     TreeElement.call(this, "", isShorthand);
     this._style = property.ownerStyle;
-    this._cascade = cascade;
+    this._matchedStyles = matchedStyles;
     this.property = property;
     this._inherited = inherited;
     this._overloaded = overloaded;
     this.selectable = false;
     this._parentPane = stylesPane;
     this.isShorthand = isShorthand;
     this._applyStyleThrottler = new WebInspector.Throttler(0);
 }
 
 /** @typedef {{expanded: boolean, hasChildren: boolean, isEditingName: boolean, previousContent: string}} */
@@ skipping 199 matching lines @@
         if (section && section._parentPane)
             section._parentPane._refreshUpdate(section);
     },
 
     /**
      * @param {!WebInspector.TextRange} oldStyleRange
      */
     _styleTextEdited: function(oldStyleRange)
     {
         var newStyleRange = /** @type {!WebInspector.TextRange} */ (this._style.range);
-        this._cascade.resetActiveProperties();
+        this._matchedStyles.resetActiveProperties();
         if (this._style.parentRule)
             this._parentPane._styleSheetRuleEdited(this._style.parentRule, oldStyleRange, newStyleRange);
     },
 
     /**
      * @param {!Event} event
      */
     _toggleEnabled: function(event)
     {
         var disabled = !event.target.checked;
@@ skipping 33 matching lines @@
 
         var longhandProperties = this._style.longhandProperties(this.name);
         for (var i = 0; i < longhandProperties.length; ++i) {
             var name = longhandProperties[i].name;
             var inherited = false;
             var overloaded = false;
 
             var section = this.section();
             if (section) {
                 inherited = section.isPropertyInherited(name);
-                overloaded = this._cascade.propertyState(longhandProperties[i]) === WebInspector.SectionCascade.PropertyState.Overloaded;
+                overloaded = this._matchedStyles.propertyState(longhandProperties[i]) === WebInspector.CSSStyleModel.MatchedStyleResult.PropertyState.Overloaded;
             }
 
-            var item = new WebInspector.StylePropertyTreeElement(this._parentPane, this._cascade, longhandProperties[i], false, inherited, overloaded);
+            var item = new WebInspector.StylePropertyTreeElement(this._parentPane, this._matchedStyles, longhandProperties[i], false, inherited, overloaded);
             this.appendChild(item);
         }
     },
 
     /**
      * @override
      */
     onattach: function()
     {
         this.updateTitle();
@@ skipping 916 matching lines @@
     WebInspector.context.addFlavorChangeListener(WebInspector.DOMNode, onNodeChanged);
     onNodeChanged();
     return button;
 
     function onNodeChanged()
     {
         var node = WebInspector.context.flavor(WebInspector.DOMNode);
         button.setEnabled(!!node);
     }
 }