DevTools: kill WebInspector.SectionCascade class

third_party/WebKit/Source/devtools/front_end/elements/ComputedStyleWidget.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 106 matching lines @@
         var color = WebInspector.Color.parse(text);
         if (!color)
             return createTextNode(text);
         var swatch = WebInspector.ColorSwatch.create();
         swatch.setColorText(text);
         return swatch;
     },
 
     /**
      * @param {?WebInspector.SharedSidebarModel.ComputedStyle} nodeStyle
-     * @param {?{matched: !WebInspector.SectionCascade, pseudo: !Map.<number, !WebInspector.SectionCascade>}} cascades
+     * @param {?WebInspector.CSSStyleModel.MatchedStyleResult} matchedStyles
      */
-    _innerRebuildUpdate: function(nodeStyle, cascades)
+    _innerRebuildUpdate: function(nodeStyle, matchedStyles)
     {
         this._propertiesOutline.removeChildren();
         this._linkifier.reset();
         var cssModel = this._sharedModel.cssModel();
-        if (!nodeStyle || !cascades || !cssModel)
+        if (!nodeStyle || !matchedStyles || !cssModel)
             return;
 
         var uniqueProperties = nodeStyle.computedStyle.keysArray();
         uniqueProperties.sort(propertySorter);
 
-        var propertyTraces = this._computePropertyTraces(cascades.matched);
-        var inhertiedProperties = this._computeInheritedProperties(cascades.matched);
+        var propertyTraces = this._computePropertyTraces(matchedStyles);
+        var inhertiedProperties = this._computeInheritedProperties(matchedStyles);
         var showInherited = this._showInheritedComputedStylePropertiesSetting.get();
         for (var i = 0; i < uniqueProperties.length; ++i) {
             var propertyName = uniqueProperties[i];
             var propertyValue = nodeStyle.computedStyle.get(propertyName);
             var canonicalName = WebInspector.CSSMetadata.canonicalPropertyName(propertyName);
             var inherited = !inhertiedProperties.has(canonicalName);
             if (!showInherited && inherited && !(propertyName in this._alwaysShowComputedProperties))
                 continue;
             if (propertyName !== canonicalName && propertyValue === nodeStyle.computedStyle.get(canonicalName))
                 continue;
@@ skipping 16 matching lines @@
             treeElement[WebInspector.ComputedStyleWidget._propertySymbol] = {
                 name: propertyName,
                 value: propertyValue
             };
             var isOdd = this._propertiesOutline.rootElement().children().length % 2 === 0;
             treeElement.listItemElement.classList.toggle("odd-row", isOdd);
             this._propertiesOutline.appendChild(treeElement);
 
             var trace = propertyTraces.get(propertyName);
             if (trace) {
-                this._renderPropertyTrace(cssModel, cascades.matched, nodeStyle.node, treeElement, trace);
+                this._renderPropertyTrace(cssModel, matchedStyles, nodeStyle.node, treeElement, trace);
                 treeElement.listItemElement.addEventListener("mousedown", consumeEvent, false);
                 treeElement.listItemElement.addEventListener("dblclick", consumeEvent, false);
                 treeElement.listItemElement.addEventListener("click", handleClick.bind(null, treeElement), false);
             }
         }
 
         this._updateFilter(this._filterRegex);
 
         /**
          * @param {string} a
@@ skipping 17 matching lines @@
             if (!treeElement.expanded)
                 treeElement.expand();
             else
                 treeElement.collapse();
             consumeEvent(event);
         }
     },
 
     /**
      * @param {!WebInspector.CSSStyleModel} cssModel
-     * @param {!WebInspector.SectionCascade} matchedCascade
+     * @param {!WebInspector.CSSStyleModel.MatchedStyleResult} matchedStyles
      * @param {!WebInspector.DOMNode} node
      * @param {!TreeElement} rootTreeElement
      * @param {!Array<!WebInspector.CSSProperty>} tracedProperties
      */
-    _renderPropertyTrace: function(cssModel, matchedCascade, node, rootTreeElement, tracedProperties)
+    _renderPropertyTrace: function(cssModel, matchedStyles, node, rootTreeElement, tracedProperties)
     {
         for (var property of tracedProperties) {
             var trace = createElement("div");
             trace.classList.add("property-trace");
-            if (matchedCascade.propertyState(property) === WebInspector.SectionCascade.PropertyState.Overloaded)
+            if (matchedStyles.propertyState(property) === WebInspector.CSSStyleModel.MatchedStyleResult.PropertyState.Overloaded)
                 trace.classList.add("property-trace-inactive");
 
             var renderer = new WebInspector.StylesSidebarPropertyRenderer(null, node, property.name, /** @type {string} */(property.value));
             renderer.setColorHandler(this._processColor.bind(this));
             var valueElement = renderer.renderValue();
             valueElement.classList.add("property-trace-value");
             trace.appendChild(valueElement);
 
             var rule = property.ownerStyle.parentRule;
             if (rule) {
                 var linkSpan = trace.createChild("span", "trace-link");
                 linkSpan.appendChild(WebInspector.StylePropertiesSection.createRuleOriginNode(cssModel, this._linkifier, rule));
             }
 
             var selectorElement = trace.createChild("span", "property-trace-selector");
             selectorElement.textContent = rule ? rule.selectorText() : "element.style";
             selectorElement.title = selectorElement.textContent;
 
             var traceTreeElement = new TreeElement();
             traceTreeElement.title = trace;
             traceTreeElement.selectable = false;
             rootTreeElement.appendChild(traceTreeElement);
         }
     },
 
     /**
-     * @param {!WebInspector.SectionCascade} matchedCascade
+     * @param {!WebInspector.CSSStyleModel.MatchedStyleResult} matchedStyles
      * @return {!Map<string, !Array<!WebInspector.CSSProperty>>}
      */
-    _computePropertyTraces: function(matchedCascade)
+    _computePropertyTraces: function(matchedStyles)
     {
         var result = new Map();
-        var styles = matchedCascade.styles();
-        for (var style of styles) {
+        for (var style of matchedStyles.nodeStyles()) {
             var allProperties = style.allProperties;
             for (var property of allProperties) {
-                if (!property.activeInStyle() || !matchedCascade.propertyState(property))
+                if (!property.activeInStyle() || !matchedStyles.propertyState(property))
                     continue;
                 if (!result.has(property.name))
                     result.set(property.name, []);
                 result.get(property.name).push(property);
             }
         }
         return result;
     },
 
     /**
-     * @param {!WebInspector.SectionCascade} matchedCascade
+     * @param {!WebInspector.CSSStyleModel.MatchedStyleResult} matchedStyles
      * @return {!Set<string>}
      */
-    _computeInheritedProperties: function(matchedCascade)
+    _computeInheritedProperties: function(matchedStyles)
     {
         var result = new Set();
-        for (var style of matchedCascade.styles()) {
+        for (var style of matchedStyles.nodeStyles()) {
             for (var property of style.allProperties) {
-                if (!matchedCascade.propertyState(property))
+                if (!matchedStyles.propertyState(property))
                     continue;
                 result.add(WebInspector.CSSMetadata.canonicalPropertyName(property.name));
             }
         }
         return result;
     },
 
     /**
      * @param {?RegExp} regex
      */
     _updateFilter: function(regex)
     {
         var children = this._propertiesOutline.rootElement().children();
         for (var child of children) {
             var property = child[WebInspector.ComputedStyleWidget._propertySymbol];
             var matched = !regex || regex.test(property.name) || regex.test(property.value);
             child.hidden = !matched;
         }
     },
 
     __proto__: WebInspector.ThrottledWidget.prototype
 }