DevTools: kill WebInspector.StylesSectionModel class

third_party/WebKit/Source/devtools/front_end/sdk/CSSStyleModel.js

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 634 matching lines @@
     this.type = type;
 }
 
 /** @enum {string} */
 WebInspector.CSSStyleDeclaration.Type = {
     Regular: "Regular",
     Inline: "Inline",
     Attributes: "Attributes"
 }
 
-/**
- * @param {!WebInspector.CSSStyleModel} cssModel
- * @return {!WebInspector.CSSStyleDeclaration}
- */
-WebInspector.CSSStyleDeclaration.createDummyStyle = function(cssModel)
-{
-    var dummyPayload = {
-        shorthandEntries: [],
-        cssProperties: []
-    };
-    return new WebInspector.CSSStyleDeclaration(cssModel, null, dummyPayload, WebInspector.CSSStyleDeclaration.Type.Regular);
-}
-
 WebInspector.CSSStyleDeclaration.prototype = {
     /**
      * @param {!CSSAgent.CSSStyle} payload
      */
     _reinitialize: function(payload)
     {
         this.styleSheetId = payload.styleSheetId;
         this.range = payload.range ? WebInspector.TextRange.fromObject(payload.range) : null;
 
         var shorthandEntries = payload.shorthandEntries;
@@ skipping 353 matching lines @@
     if (this.styleSheetId) {
         var styleSheetHeader = cssModel.styleSheetHeaderForId(this.styleSheetId);
         this.sourceURL = styleSheetHeader.sourceURL;
     }
     this.origin = payload.origin;
     this.style = new WebInspector.CSSStyleDeclaration(this._cssModel, this, payload.style, WebInspector.CSSStyleDeclaration.Type.Regular);
     if (payload.media)
         this.media = WebInspector.CSSMedia.parseMediaArrayPayload(cssModel, payload.media);
 }
 
+/**
+ * @param {!WebInspector.CSSStyleModel} cssModel
+ * @param {string} selectorText
+ * @return {!WebInspector.CSSRule}
+ */
+WebInspector.CSSRule.createDummyRule = function(cssModel, selectorText)
+{
+    var dummyPayload = {
+        selectorList: {
+            selectors: [{ value: selectorText}],
+        },
+        style: {
+            styleSheetId: "0",
+            range: new WebInspector.TextRange(0, 0, 0, 0),
+            shorthandEntries: [],
+            cssProperties: []
+        }
+    };
+    return new WebInspector.CSSRule(cssModel, /** @type {!CSSAgent.CSSRule} */(dummyPayload));
+}
+
 WebInspector.CSSRule.prototype = {
     /**
      * @param {!DOMAgent.NodeId} nodeId
      * @param {string} newSelector
      * @param {function(boolean)} userCallback
      */
     setSelectorText: function(nodeId, newSelector, userCallback)
     {
         /**
          * @param {?Protocol.Error} error
@@ skipping 180 matching lines @@
      * @return {boolean}
      */
     isRegular: function()
     {
         return this.origin === CSSAgent.StyleSheetOrigin.Regular;
     }
 }
 
 /**
  * @constructor
- * @param {?WebInspector.CSSStyleDeclaration} ownerStyle
+ * @param {!WebInspector.CSSStyleDeclaration} ownerStyle
  * @param {number} index
  * @param {string} name
  * @param {string} value
  * @param {boolean} important
  * @param {boolean} disabled
  * @param {boolean} parsedOk
  * @param {boolean} implicit
  * @param {?string=} text
  * @param {!CSSAgent.SourceRange=} range
  */
 WebInspector.CSSProperty = function(ownerStyle, index, name, value, important, disabled, parsedOk, implicit, text, range)
 {
     this.ownerStyle = ownerStyle;
     this.index = index;
     this.name = name;
     this.value = value;
     this.important = important;
     this.disabled = disabled;
     this.parsedOk = parsedOk;
     this.implicit = implicit; // A longhand, implicitly set by missing values of shorthand.
     this.text = text;
     this.range = range ? WebInspector.TextRange.fromObject(range) : null;
     this._active = true;
 }
 
 /**
- * @param {?WebInspector.CSSStyleDeclaration} ownerStyle
+ * @param {!WebInspector.CSSStyleDeclaration} ownerStyle
  * @param {number} index
  * @param {!CSSAgent.CSSProperty} payload
  * @return {!WebInspector.CSSProperty}
  */
 WebInspector.CSSProperty.parsePayload = function(ownerStyle, index, payload)
 {
     // The following default field values are used in the payload:
     // important: false
     // parsedOk: true
     // implicit: false
@@ skipping 766 matching lines @@
  * @param {!Array.<!CSSAgent.PseudoElementMatches>=} pseudoPayload
  * @param {!Array.<!CSSAgent.InheritedStyleEntry>=} inheritedPayload
  */
 WebInspector.CSSStyleModel.MatchedStyleResult = function(cssModel, nodeId, inlinePayload, attributesPayload, matchedPayload, pseudoPayload, inheritedPayload)
 {
     this._cssModel = cssModel;
     this._node = this._cssModel._domModel.nodeForId(nodeId);
 
     this._nodeStyles = [];
     this._nodeForStyle = new Map();
+    this._inheritedStyles = new Set();
 
     /**
      * @this {WebInspector.CSSStyleModel.MatchedStyleResult}
      */
     function addAttributesStyle()
     {
         if (!attributesPayload)
             return;
         var style = new WebInspector.CSSStyleDeclaration(cssModel, null, attributesPayload, WebInspector.CSSStyleDeclaration.Type.Attributes);
         this._nodeForStyle.set(style, this._node);
@@ skipping 26 matching lines @@
 
     // Walk the node structure and identify styles with inherited properties.
     var parentNode = this._node.parentNode;
     for (var i = 0; inheritedPayload && i < inheritedPayload.length; ++i) {
         var entryPayload = inheritedPayload[i];
         var inheritedInlineStyle = entryPayload.inlineStyle ? new WebInspector.CSSStyleDeclaration(cssModel, null, entryPayload.inlineStyle, WebInspector.CSSStyleDeclaration.Type.Inline) : null;
         var inheritedMatchedCSSRules = entryPayload.matchedCSSRules ? WebInspector.CSSStyleModel.parseRuleMatchArrayPayload(cssModel, entryPayload.matchedCSSRules) : null;
         if (inheritedInlineStyle && this._containsInherited(inheritedInlineStyle)) {
             this._nodeForStyle.set(inheritedInlineStyle, parentNode);
             this._nodeStyles.push(inheritedInlineStyle);
+            this._inheritedStyles.add(inheritedInlineStyle);
         }
 
         for (var j = inheritedMatchedCSSRules.length - 1; j >= 0; --j) {
             var inheritedRule = inheritedMatchedCSSRules[j];
             if (!this._containsInherited(inheritedRule.style))
                 continue;
             this._nodeForStyle.set(inheritedRule.style, parentNode);
             this._nodeStyles.push(inheritedRule.style);
+            this._inheritedStyles.add(inheritedRule.style);
         }
         parentNode = parentNode.parentNode;
     }
 
     // Set up pseudo styles map.
     this._pseudoStyles = new Map();
     if (pseudoPayload) {
         for (var i = 0; i < pseudoPayload.length; ++i) {
             var entryPayload = pseudoPayload[i];
             var pseudoElement = this._node.pseudoElements().get(entryPayload.pseudoType);
@@ skipping 50 matching lines @@
     {
         return this._nodeForStyle.get(style) || null;
     },
 
     /**
      * @param {!WebInspector.CSSStyleDeclaration} style
      * @return {boolean}
      */
     isInherited: function(style)
     {
-        return this.nodeForStyle(style) !== this._node;
+        return this._inheritedStyles.has(style);
     }
 }
 
 /**
  * @constructor
  * @param {?WebInspector.CSSStyleDeclaration} inlineStyle
  * @param {?WebInspector.CSSStyleDeclaration} attributesStyle
  */
 WebInspector.CSSStyleModel.InlineStyleResult = function(inlineStyle, attributesStyle)
 {
     this.inlineStyle = inlineStyle;
     this.attributesStyle = attributesStyle;
 }