DevTools: [CSS] promisify CSSStyleModel fetching methods

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 65 matching lines @@
     PseudoStateForced: "PseudoStateForced",
     StyleSheetAdded: "StyleSheetAdded",
     StyleSheetChanged: "StyleSheetChanged",
     StyleSheetRemoved: "StyleSheetRemoved"
 }
 
 WebInspector.CSSStyleModel.MediaTypes = ["all", "braille", "embossed", "handheld", "print", "projection", "screen", "speech", "tty", "tv"];
 
 WebInspector.CSSStyleModel.prototype = {
     /**
-     * @param {function(!Array.<!WebInspector.CSSMedia>)} userCallback
+     * @return {!Promise.<!Array.<!WebInspector.CSSMedia>>}
      */
-    getMediaQueries: function(userCallback)
+    mediaQueriesPromise: function()
     {
         /**
          * @param {?Protocol.Error} error
          * @param {?Array.<!CSSAgent.CSSMedia>} payload
          * @return {!Array.<!WebInspector.CSSMedia>}
          * @this {!WebInspector.CSSStyleModel}
          */
         function parsePayload(error, payload)
         {
             return !error && payload ? WebInspector.CSSMedia.parseMediaArrayPayload(this, payload) : [];
         }
 
-        this._agent.getMediaQueries(parsePayload.bind(this))
-            .catchException([])
-            .then(userCallback);
+        return this._agent.getMediaQueries(parsePayload.bind(this));
     },
 
     /**
      * @return {boolean}
      */
     isEnabled: function()
     {
         return this._isEnabled;
     },
 
@@ skipping 51 matching lines @@
                 }
             }
             return new WebInspector.CSSStyleModel.MatchedStyleResult(matchedRules, inherited, pseudoElements);
         }
 
         return this._agent.getMatchedStylesForNode(nodeId, excludePseudo, excludeInherited, callback.bind(this));
     },
 
     /**
      * @param {!DOMAgent.NodeId} nodeId
-     * @param {boolean} excludePseudo
-     * @param {boolean} excludeInherited
-     * @param {function(?WebInspector.CSSStyleModel.MatchedStyleResult)} userCallback
+     * @return {!Promise.<?WebInspector.CSSStyleDeclaration>}
      */
-    getMatchedStylesAsync: function(nodeId, excludePseudo, excludeInherited, userCallback)
+    computedStylePromise: function(nodeId)
     {
-        this.matchedStylesPromise(nodeId, excludePseudo, excludeInherited)
-            .catchException(null)
-            .then(userCallback);
-    },
-
-    /**
-     * @param {!DOMAgent.NodeId} nodeId
-     * @param {function(?WebInspector.CSSStyleDeclaration)} userCallback
-     */
-    getComputedStyleAsync: function(nodeId, userCallback)
-    {
-        this._styleLoader.getComputedStyle(nodeId, userCallback);
+        return this._styleLoader.computedStylePromise(nodeId);
     },
 
     /**
      * @param {number} nodeId
-     * @param {function(?Array.<!CSSAgent.PlatformFontUsage>)} callback
+     * @return {!Promise.<?Array.<!CSSAgent.PlatformFontUsage>>}
      */
-    getPlatformFontsForNode: function(nodeId, callback)
+    platformFontsPromise: function(nodeId)
     {
         /**
          * @param {?Protocol.Error} error
          * @param {?Array.<!CSSAgent.PlatformFontUsage>} fonts
          * @return {?Array.<!CSSAgent.PlatformFontUsage>}
          */
         function platformFontsCallback(error, fonts)
         {
             return !error && fonts ? fonts : null;
         }
 
-        this._agent.getPlatformFontsForNode(nodeId, platformFontsCallback)
-            .catchException(null)
-            .then(callback)
+        return this._agent.getPlatformFontsForNode(nodeId, platformFontsCallback);
     },
 
     /**
      * @return {!Array.<!WebInspector.CSSStyleSheetHeader>}
      */
     allStyleSheets: function()
     {
         var values = this._styleSheetIdToHeader.valuesArray();
         /**
          * @param {!WebInspector.CSSStyleSheetHeader} a
@@ skipping 32 matching lines @@
                 return null;
             var inlineStyle = inlinePayload ? WebInspector.CSSStyleDeclaration.parsePayload(this, inlinePayload) : null;
             var attributesStyle = attributesStylePayload ? WebInspector.CSSStyleDeclaration.parsePayload(this, attributesStylePayload) : null;
             return new WebInspector.CSSStyleModel.InlineStyleResult(inlineStyle, attributesStyle);
         }
 
         return this._agent.getInlineStylesForNode(nodeId, callback.bind(this));
     },
 
     /**
-     * @param {!DOMAgent.NodeId} nodeId
-     * @param {function(?WebInspector.CSSStyleModel.InlineStyleResult)} userCallback
-     */
-    getInlineStylesAsync: function(nodeId, userCallback)
-    {
-        this.inlineStylesPromise(nodeId)
-            .catchException(null)
-            .then(userCallback);
-    },
-
-    /**
      * @param {!WebInspector.DOMNode} node
      * @param {string} pseudoClass
      * @param {boolean} enable
      * @return {boolean}
      */
     forcePseudoState: function(node, pseudoClass, enable)
     {
         var pseudoClasses = node.getUserProperty(WebInspector.CSSStyleModel.PseudoStatePropertyName) || [];
         if (enable) {
             if (pseudoClasses.indexOf(pseudoClass) >= 0)
@@ skipping 1623 matching lines @@
     },
 }
 
 /**
  * @constructor
  * @param {!WebInspector.CSSStyleModel} cssModel
  */
 WebInspector.CSSStyleModel.ComputedStyleLoader = function(cssModel)
 {
     this._cssModel = cssModel;
-    /** @type {!Object.<*, !Array.<function(?WebInspector.CSSStyleDeclaration)>>} */
-    this._nodeIdToCallbackData = {};
+    /** @type {!Map.<!DOMAgent.NodeId, !Promise.<?WebInspector.CSSStyleDeclaration>>} */
+    this._nodeIdToPromise = new Map();
 }
 
 WebInspector.CSSStyleModel.ComputedStyleLoader.prototype = {
     /**
      * @param {!DOMAgent.NodeId} nodeId
-     * @param {function(?WebInspector.CSSStyleDeclaration)} userCallback
+     * @return {!Promise.<?WebInspector.CSSStyleDeclaration>}
      */
-    getComputedStyle: function(nodeId, userCallback)
+    computedStylePromise: function(nodeId)
     {
-        if (this._nodeIdToCallbackData[nodeId]) {
-            this._nodeIdToCallbackData[nodeId].push(userCallback);
-            return;
-        }
+        if (!this._nodeIdToPromise[nodeId])
+            this._nodeIdToPromise[nodeId] = this._cssModel._agent.getComputedStyleForNode(nodeId, parsePayload.bind(this)).then(cleanUp.bind(this));
 
-        this._nodeIdToCallbackData[nodeId] = [userCallback];
-
-        this._cssModel._agent.getComputedStyleForNode(nodeId, parsePayload.bind(this))
-            .catchException(null)
-            .then(broadcast.bind(this, nodeId))
+        return this._nodeIdToPromise[nodeId];
 
         /**
          * @param {?Protocol.Error} error
          * @param {!Array.<!CSSAgent.CSSComputedStyleProperty>} computedPayload
          * @return {?WebInspector.CSSStyleDeclaration}
          * @this {WebInspector.CSSStyleModel.ComputedStyleLoader}
          */
         function parsePayload(error, computedPayload)
         {
             return !error && computedPayload ? WebInspector.CSSStyleDeclaration.parseComputedStylePayload(this._cssModel, computedPayload) : null;
         }
 
         /**
-         * @param {!DOMAgent.NodeId} nodeId
          * @param {?WebInspector.CSSStyleDeclaration} computedStyle
+         * @return {?WebInspector.CSSStyleDeclaration}
          * @this {WebInspector.CSSStyleModel.ComputedStyleLoader}
          */
-        function broadcast(nodeId, computedStyle)
+        function cleanUp(computedStyle)
         {
-            var callbacks = this._nodeIdToCallbackData[nodeId];
-
-            // The loader has been reset.
-            if (!callbacks)
-                return;
-
-            delete this._nodeIdToCallbackData[nodeId];
-            for (var i = 0; i < callbacks.length; ++i)
-                callbacks[i](computedStyle);
+            delete this._nodeIdToPromise[nodeId];
+            return computedStyle;
         }
     }
 }
 
 /**
  * @param {!WebInspector.Target} target
  * @return {?WebInspector.CSSStyleModel}
  */
 WebInspector.CSSStyleModel.fromTarget = function(target)
 {
@@ skipping 50 matching lines @@
  * @constructor
  * @param {?WebInspector.CSSStyleDeclaration} inlineStyle
  * @param {?WebInspector.CSSStyleDeclaration} attributesStyle
  */
 WebInspector.CSSStyleModel.InlineStyleResult = function(inlineStyle, attributesStyle)
 {
     this.inlineStyle = inlineStyle;
     this.attributesStyle = attributesStyle;
 }