DevTools: Split creating inspector stylesheet and adding a new rule into stylesheet in protocol.

Source/devtools/front_end/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 263 matching lines @@
         function selectorQueried(index, nodeId, matchingSelectors, matchingNodeIds)
         {
             if (!matchingNodeIds)
                 return;
             if (matchingNodeIds.indexOf(nodeId) !== -1)
                 matchingSelectors.push(index);
         }
     },
 
     /**
-     * @param {!DOMAgent.NodeId} nodeId
+     * @param {!CSSAgent.StyleSheetId} styleSheetId
+     * @param {!WebInspector.DOMNode} node
      * @param {string} selector
      * @param {function(!WebInspector.CSSRule)} successCallback
      * @param {function()} failureCallback
      */
-    addRule: function(nodeId, selector, successCallback, failureCallback)
+    addRule: function(styleSheetId, node, selector, successCallback, failureCallback)
     {
+        this._pendingCommandsMajorState.push(true);
+        CSSAgent.addRule(styleSheetId, selector, callback.bind(this));
+
         /**
          * @param {?Protocol.Error} error
          * @param {!CSSAgent.CSSRule} rulePayload
          * @this {WebInspector.CSSStyleModel}
          */
         function callback(error, rulePayload)
         {
             this._pendingCommandsMajorState.pop();
             if (error) {
                 // Invalid syntax for a selector
                 failureCallback();
             } else {
                 WebInspector.domAgent.markUndoableState();
-                this._computeMatchingSelectors(rulePayload, nodeId, successCallback, failureCallback);
+                this._computeMatchingSelectors(rulePayload, node.id, successCallback, failureCallback);
+            }
+        }
+    },
+
+    /**
+     * @param {!WebInspector.DOMNode} node
+     * @param {function(?WebInspector.CSSStyleSheetHeader)} callback
+     */
+    requestViaInspectorStylesheet: function(node, callback)

[lushnikov, 2014/02/28 11:55:59]

ensureViaInspectorStyleSheet? 

[vsevik, 2014/02/28 14:35:28]

I prefer requestViaInspectorStyleSheet.

+    {
+        var frameId = node.frameId() || WebInspector.resourceTreeModel.mainFrame.id;
+        var viaInspectorStyleSheetHeader;
+        for (var styleSheetId in this._styleSheetIdToHeader) {
+            var styleSheetHeader = this._styleSheetIdToHeader[styleSheetId];
+            if (styleSheetHeader.frameId === frameId && styleSheetHeader.isViaInspector()) {
+                viaInspectorStyleSheetHeader = styleSheetHeader;

[lushnikov, 2014/02/28 11:55:59]

we don't need viaInspectorStyleSheetHeader var - let's call
callback(styleSheetHeader) right here

[vsevik, 2014/02/28 14:35:28]

Done.

+                break;
             }
         }
 
-        this._pendingCommandsMajorState.push(true);
-        CSSAgent.addRule(nodeId, selector, callback.bind(this));
+        if (viaInspectorStyleSheetHeader) {
+            callback(viaInspectorStyleSheetHeader);
+            return;
+        }
+
+        /**
+         * @this {WebInspector.CSSStyleModel}
+         * @param {?Protocol.Error} error
+         * @param {!CSSAgent.StyleSheetId} styleSheetId
+         */
+        function innerCallback(error, styleSheetId)
+        {
+            if (error) {
+                console.error(error);
+                callback(null);
+            }
+
+            callback(this._styleSheetIdToHeader[styleSheetId]);
+        }
+
+        CSSAgent.createViaInspectorStyleSheet(frameId, innerCallback.bind(this));
     },
 
     mediaQueryResultChanged: function()
     {
         this._styleLoader.reset();
         this.dispatchEventToListeners(WebInspector.CSSStyleModel.Events.MediaQueryResultChanged);
     },
 
     /**
      * @param {!CSSAgent.StyleSheetId} id
@@ skipping 938 matching lines @@
     /** @type {!Array.<!WebInspector.SourceMapping>} */
     this._sourceMappings = [];
 }
 
 WebInspector.CSSStyleSheetHeader.prototype = {
     /**
      * @return {string}
      */
     resourceURL: function()
     {
-        return this.origin === "inspector" ? this._viaInspectorResourceURL() : this.sourceURL;
+        return this.isViaInspector() ? this._viaInspectorResourceURL() : this.sourceURL;
     },
 
     /**
      * @param {!WebInspector.CSSStyleModel.LiveLocation} location
      */
     addLiveLocation: function(location)
     {
         this._locations.add(location);
         location.update();
     },
@@ skipping 139 matching lines @@
      * @param {string} newText
      * @param {function(?Protocol.Error)} callback
      */
     setContent: function(newText, callback)
     {
         newText = this._trimSourceURL(newText);
         if (this.hasSourceURL)
             newText += "\n/*# sourceURL=" + this.sourceURL + " */";
         CSSAgent.setStyleSheetText(this.id, newText, callback);
     },
+
+    /**
+     * @return {boolean}
+     */
+    isViaInspector: function()
+    {
+        return this.origin === "inspector";
+    },
+
 }
 
 /**
  * @constructor
  * @implements {CSSAgent.Dispatcher}
  * @param {!WebInspector.CSSStyleModel} cssModel
  */
 WebInspector.CSSDispatcher = function(cssModel)
 {
     this._cssModel = cssModel;
@@ skipping 86 matching lines @@
             for (var i = 0; i < callbacks.length; ++i)
                 callbacks[i](computedStyle);
         }
     }
 }
 
 /**
  * @type {!WebInspector.CSSStyleModel}
  */
 WebInspector.cssModel;