DevTools: promisify ContentProvider.requestContent and all its clients.

third_party/WebKit/Source/devtools/front_end/workspace/UISourceCode.js

 /*
  * Copyright (C) 2011 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 30 matching lines @@
 {
     this._project = project;
     this._url = url;
 
     var pathComponents = WebInspector.ParsedURL.splitURLIntoPathComponents(url);
     this._origin = pathComponents[0];
     this._parentURL = pathComponents.slice(0, -1).join("/");
     this._name = pathComponents[pathComponents.length - 1];
 
     this._contentType = contentType;
-    /** @type {!Array.<function(?string)>} */
-    this._requestContentCallbacks = [];
+    /** @type {?function(?string)} */
+    this._requestContentCallback = null;
+    /** @type {?Promise<?string>} */
+    this._requestContentPromise = null;
 
     /** @type {!Array.<!WebInspector.Revision>} */
     this.history = [];
     this._hasUnsavedCommittedChanges = false;
 
     /** @type {!Array<!WebInspector.UISourceCode.Message>} */
     this._messages = [];
 }
 
 /**
@@ skipping 152 matching lines @@
     /**
      * @return {!WebInspector.Project}
      */
     project: function()
     {
         return this._project;
     },
 
     /**
      * @override
-     * @param {function(?string)} callback
+     * @return {!Promise<?string>}
      */
-    requestContent: function(callback)
+    requestContent: function()
     {
-        if (this._content || this._contentLoaded) {
-            callback(this._content);
-            return;
+        if (this._content || this._contentLoaded)

[pfeldman, 2016/01/20 19:23:51]

return this._requestContentPromise if we have one.

[lushnikov, 2016/01/20 23:35:58]

Acknowledged.

+            return Promise.resolve(this._content);
+        var promise = this._requestContentPromise;
+        if (!promise) {
+            promise = new Promise(fulfill => this._requestContentCallback = fulfill);
+            this._requestContentPromise = promise;
+            this._project.requestFileContent(this, this._fireContentAvailable.bind(this));
         }
-        this._requestContentCallbacks.push(callback);
-        if (this._requestContentCallbacks.length === 1)
-            this._project.requestFileContent(this, this._fireContentAvailable.bind(this));
+        return promise;
     },
 
     /**
-     * @return {!Promise.<?string>}
-     */
-    requestContentPromise: function()
-    {
-        return new Promise(succ => this.requestContent(succ));
-    },
-
-    /**
      * @param {function()} callback
      */
     _pushCheckContentUpdatedCallback: function(callback)
     {
         if (!this._checkContentUpdatedCallbacks)
             this._checkContentUpdatedCallbacks = [];
         this._checkContentUpdatedCallbacks.push(callback);
     },
 
     _terminateContentCheck: function()
@@ skipping 68 matching lines @@
             this._terminateContentCheck();
         }
     },
 
     forceLoadOnCheckContent: function()
     {
         this._forceLoadOnCheckContent = true;
     },
 
     /**
-     * @param {function(?string)} callback
+     * @return {!Promise<?string>}
      */
-    requestOriginalContent: function(callback)
+    requestOriginalContent: function()
     {
+        var callback;
+        var promise = new Promise(fulfill => callback = fulfill);
         this._project.requestFileContent(this, callback);
+        return promise;
     },
 
     /**
      * @param {string} content
      */
     _commitContent: function(content)
     {
         var wasPersisted = false;
         if (this._project.canSetFileContent()) {
             this._project.setFileContent(this, content, function() { });
@@ skipping 58 matching lines @@
     },
 
     /**
      * @param {string} content
      */
     addRevision: function(content)
     {
         this._commitContent(content);
     },
 
+    /**
+     * @return {!Promise}
+     */
     revertToOriginal: function()
     {
         /**
          * @this {WebInspector.UISourceCode}
          * @param {?string} content
          */
         function callback(content)
         {
             if (typeof content !== "string")
                 return;
 
             this.addRevision(content);
         }
 
         WebInspector.userMetrics.actionTaken(WebInspector.UserMetrics.Action.RevisionApplied);
-        this.requestOriginalContent(callback.bind(this));
+        return this.requestOriginalContent().then(callback.bind(this));
     },
 
     /**
      * @param {function(!WebInspector.UISourceCode)} callback
      */
     revertAndClearHistory: function(callback)
     {
         /**
          * @this {WebInspector.UISourceCode}
          * @param {?string} content
          */
         function revert(content)
         {
             if (typeof content !== "string")
                 return;
 
             this.addRevision(content);
             this.history = [];
             callback(this);
         }
 
         WebInspector.userMetrics.actionTaken(WebInspector.UserMetrics.Action.RevisionApplied);
-        this.requestOriginalContent(revert.bind(this));
+        this.requestOriginalContent().then(revert.bind(this));
     },
 
     /**
      * @return {string}
      */
     workingCopy: function()
     {
         if (this._workingCopyGetter) {
             this._workingCopy = this._workingCopyGetter();
             delete this._workingCopyGetter;
@@ skipping 90 matching lines @@
     },
 
     /**
      * @param {?string} content
      */
     _fireContentAvailable: function(content)
     {
         this._contentLoaded = true;
         this._content = content;
 
-        var callbacks = this._requestContentCallbacks.slice();
-        this._requestContentCallbacks = [];
-        for (var i = 0; i < callbacks.length; ++i)
-            callbacks[i](content);
+        var callback = this._requestContentCallback;
+        this._requestContentCallback = null;
+        this._requestContentPromise = null;
+
+        callback.call(null, content);
     },
 
     /**
      * @return {boolean}
      */
     contentLoaded: function()
     {
         return this._contentLoaded;
     },
 
@@ skipping 137 matching lines @@
     },
 
     /**
      * @return {?string}
      */
     get content()
     {
         return this._content || null;
     },
 
+    /**
+     * @return {!Promise}
+     */
     revertToThis: function()
     {
         /**
-         * @param {string} content
+         * @param {?string} content
          * @this {WebInspector.Revision}
          */
         function revert(content)
         {
-            if (this._uiSourceCode._content !== content)
+            if (content && this._uiSourceCode._content !== content)
                 this._uiSourceCode.addRevision(content);
         }
         WebInspector.userMetrics.actionTaken(WebInspector.UserMetrics.Action.RevisionApplied);
-        this.requestContent(revert.bind(this));
+        return this.requestContent().then(revert.bind(this));
     },
 
     /**
      * @override
      * @return {string}
      */
     contentURL: function()
     {
         return this._uiSourceCode.url();
     },
 
     /**
      * @override
      * @return {!WebInspector.ResourceType}
      */
     contentType: function()
     {
         return this._uiSourceCode.contentType();
     },
 
     /**
      * @override
-     * @param {function(string)} callback
+     * @return {!Promise<?string>}
      */
-    requestContent: function(callback)
+    requestContent: function()
     {
-        callback(this._content || "");
+        return Promise.resolve(/** @type {?string} */(this._content || ""));
     },
 
     /**
      * @override
      * @param {string} query
      * @param {boolean} caseSensitive
      * @param {boolean} isRegex
      * @param {function(!Array.<!WebInspector.ContentProvider.SearchMatch>)} callback
      */
     searchInContent: function(query, caseSensitive, isRegex, callback)
@@ skipping 80 matching lines @@
     isEqual: function(another)
     {
         return this._uiSourceCode === another._uiSourceCode && this.text() === another.text() && this.level() === another.level() && this.range().equal(another.range());
     },
 
     remove: function()
     {
         this._uiSourceCode.removeMessage(this);
     }
 }