DevTools: Promisify Runtime domain

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

 /*
  * Copyright (C) 2009 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 363 matching lines @@
     throw 'Not implemented';
   }
 
   /**
    * @param {function(this:Object, ...):T} functionDeclaration
    * @param {!Array<!Protocol.Runtime.CallArgument>|undefined} args
    * @return {!Promise<T>}
    * @template T
    */
   callFunctionJSONPromise(functionDeclaration, args) {
-    return new Promise(promiseConstructor.bind(this));
-
-    /**
-     * @this {SDK.RemoteObject}
-     */
-    function promiseConstructor(success) {
-      this.callFunctionJSON(functionDeclaration, args, success);
-    }
+    return new Promise(success => this.callFunctionJSON(functionDeclaration, args, success));
   }
 
   release() {
   }
 
   /**
    * @return {!SDK.DebuggerModel}
    */
   debuggerModel() {
     throw new Error('DebuggerModel-less object');
@@ skipping 166 matching lines @@
     }
 
     var args = [{value: JSON.stringify(propertyPath)}];
     this.callFunction(remoteFunction, args, callback);
   }
 
   /**
    * @param {boolean} ownProperties
    * @param {boolean} accessorPropertiesOnly
    * @param {boolean} generatePreview
-   * @param {function(?Array.<!SDK.RemoteObjectProperty>, ?Array.<!SDK.RemoteObjectProperty>)} callback
+   * @param {function(?Array<!SDK.RemoteObjectProperty>, ?Array<!SDK.RemoteObjectProperty>)} callback
    */
   doGetProperties(ownProperties, accessorPropertiesOnly, generatePreview, callback) {
     if (!this._objectId) {
       callback(null, null);
       return;
     }
 
+    this._runtimeAgent
+        .invoke_getProperties({objectId: this._objectId, ownProperties, accessorPropertiesOnly, generatePreview})
+        .then(remoteObjectBinder.bind(this));
+
     /**
-     * @param {?Protocol.Error} error
-     * @param {!Array.<!Protocol.Runtime.PropertyDescriptor>} properties
-     * @param {!Array.<!Protocol.Runtime.InternalPropertyDescriptor>=} internalProperties
-     * @param {?Protocol.Runtime.ExceptionDetails=} exceptionDetails
+     * @param {!Protocol.RuntimeAgent.GetPropertiesResponse} response
      * @this {SDK.RemoteObjectImpl}
      */
-    function remoteObjectBinder(error, properties, internalProperties, exceptionDetails) {
-      if (error) {
+    function remoteObjectBinder(response) {
+      if (response[Protocol.Error]) {
         callback(null, null);
         return;
       }
-      if (exceptionDetails) {
-        this._runtimeModel.exceptionThrown(Date.now(), exceptionDetails);
+      if (response.exceptionDetails) {
+        this._runtimeModel.exceptionThrown(Date.now(), response.exceptionDetails);
         callback(null, null);
         return;
       }
+      var properties = response.result;
+      var internalProperties = response.internalProperties;
       var result = [];
       for (var i = 0; properties && i < properties.length; ++i) {
         var property = properties[i];
         var propertyValue = property.value ? this._runtimeModel.createRemoteObject(property.value) : null;
         var propertySymbol = property.symbol ? this._runtimeModel.createRemoteObject(property.symbol) : null;
         var remoteProperty = new SDK.RemoteObjectProperty(
             property.name, propertyValue, !!property.enumerable, !!property.writable, !!property.isOwn,
             !!property.wasThrown, propertySymbol);
 
         if (typeof property.value === 'undefined') {
@@ skipping 11 matching lines @@
         for (var i = 0; i < internalProperties.length; i++) {
           var property = internalProperties[i];
           if (!property.value)
             continue;
           var propertyValue = this._runtimeModel.createRemoteObject(property.value);
           internalPropertiesResult.push(new SDK.RemoteObjectProperty(property.name, propertyValue, true, false));
         }
       }
       callback(result, internalPropertiesResult);
     }
-    this._runtimeAgent.getProperties(
-        this._objectId, ownProperties, accessorPropertiesOnly, generatePreview, remoteObjectBinder.bind(this));
   }
 
   /**
    * @override
    * @param {string|!Protocol.Runtime.CallArgument} name
    * @param {string} value
    * @param {function(string=)} callback
    */
   setPropertyValue(name, value, callback) {
     if (!this._objectId) {
-      callback('Can\'t set a property of non-object.');
+      callback(`Can't set a property of non-object.`);
       return;
     }
 
     this._runtimeAgent.invoke_evaluate({expression: value, silent: true}).then(response => {
       if (response[Protocol.Error] || response.exceptionDetails) {
         callback(
             response[Protocol.Error] ||
             (response.result.type !== 'string' ? response.result.description :
                                                  /** @type {string} */ (response.result.value)));
         return;
       }
 
       if (typeof name === 'string')
         name = SDK.RemoteObject.toCallArgument(name);
 
-      this.doSetObjectPropertyValue(response.result, name, callback);
+      this.doSetObjectPropertyValue(response.result, name).then(callback);
 
       if (response.result.objectId)
         this._runtimeAgent.releaseObject(response.result.objectId);
     });
   }
 
   /**
    * @param {!Protocol.Runtime.RemoteObject} result
    * @param {!Protocol.Runtime.CallArgument} name
-   * @param {function(string=)} callback
+   * @return {!Promise<string|undefined>}
    */
-  doSetObjectPropertyValue(result, name, callback) {
+  async doSetObjectPropertyValue(result, name) {
     // This assignment may be for a regular (data) property, and for an accessor property (with getter/setter).
     // Note the sensitive matter about accessor property: the property may be physically defined in some proto object,
     // but logically it is bound to the object in question. JavaScript passes this object to getters/setters, not the object
     // where property was defined; so do we.
     var setPropertyValueFunction = 'function(a, b) { this[a] = b; }';
 
     var argv = [name, SDK.RemoteObject.toCallArgument(result)];
-    this._runtimeAgent.callFunctionOn(
-        this._objectId, setPropertyValueFunction, argv, true, undefined, undefined, undefined, undefined,
-        propertySetCallback);
-
-    /**
-     * @param {?Protocol.Error} error
-     * @param {!Protocol.Runtime.RemoteObject} result
-     * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
-     */
-    function propertySetCallback(error, result, exceptionDetails) {
-      if (error || !!exceptionDetails) {
-        callback(error || result.description);
-        return;
-      }
-      callback();
-    }
+    var response = await this._runtimeAgent.invoke_callFunctionOn(
+        {objectId: this._objectId, functionDeclaration: setPropertyValueFunction, arguments: argv, silent: true});
+    var error = response[Protocol.Error];
+    return error || response.exceptionDetails ? error || response.result.description : undefined;
   }
 
   /**
    * @override
    * @param {!Protocol.Runtime.CallArgument} name
    * @param {function(string=)} callback
    */
   deleteProperty(name, callback) {
     if (!this._objectId) {
-      callback('Can\'t delete a property of non-object.');
+      callback(`Can't delete a property of non-object.`);
       return;
     }
 
     var deletePropertyFunction = 'function(a) { delete this[a]; return !(a in this); }';
-    this._runtimeAgent.callFunctionOn(
-        this._objectId, deletePropertyFunction, [name], true, undefined, undefined, undefined, undefined,
-        deletePropertyCallback);
-
-    /**
-     * @param {?Protocol.Error} error
-     * @param {!Protocol.Runtime.RemoteObject} result
-     * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
-     */
-    function deletePropertyCallback(error, result, exceptionDetails) {
-      if (error || !!exceptionDetails) {
-        callback(error || result.description);
-        return;
-      }
-      if (!result.value)
-        callback('Failed to delete property.');
-      else
-        callback();
-    }
+    this._runtimeAgent
+        .invoke_callFunctionOn(
+            {objectId: this._objectId, functionDeclaration: deletePropertyFunction, arguments: [name], silent: true})
+        .then(response => {
+          if (response[Protocol.Error] || response.exceptionDetails) {
+            callback(response[Protocol.Error] || response.result.description);
+            return;
+          }
+          if (!response.result.value)
+            callback('Failed to delete property.');
+          else
+            callback();
+        });
   }
 
   /**
    * @override
    * @param {function(this:Object, ...)} functionDeclaration
    * @param {!Array.<!Protocol.Runtime.CallArgument>=} args
    * @param {function(?SDK.RemoteObject, boolean=)=} callback
    */
   callFunction(functionDeclaration, args, callback) {
-    /**
-     * @param {?Protocol.Error} error
-     * @param {!Protocol.Runtime.RemoteObject} result
-     * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
-     * @this {SDK.RemoteObjectImpl}
-     */
-    function mycallback(error, result, exceptionDetails) {
-      if (!callback)
-        return;
-      if (error)
-        callback(null, false);
-      else
-        callback(this._runtimeModel.createRemoteObject(result), !!exceptionDetails);
-    }
-
-    this._runtimeAgent.callFunctionOn(
-        this._objectId, functionDeclaration.toString(), args, true, undefined, undefined, undefined, undefined,
-        mycallback.bind(this));
+    this._runtimeAgent
+        .invoke_callFunctionOn({
+          objectId: this._objectId,
+          functionDeclaration: functionDeclaration.toString(),
+          arguments: args,
+          silent: true
+        })
+        .then(response => {
+          if (!callback)
+            return;
+          if (response[Protocol.Error])
+            callback(null, false);
+          else
+            callback(this._runtimeModel.createRemoteObject(response.result), !!response.exceptionDetails);
+        });
   }
 
   /**
    * @override
    * @param {function(this:Object)} functionDeclaration
    * @param {!Array.<!Protocol.Runtime.CallArgument>|undefined} args
    * @param {function(*)} callback
    */
   callFunctionJSON(functionDeclaration, args, callback) {
-    /**
-     * @param {?Protocol.Error} error
-     * @param {!Protocol.Runtime.RemoteObject} result
-     * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
-     */
-    function mycallback(error, result, exceptionDetails) {
-      callback((error || !!exceptionDetails) ? null : result.value);
-    }
-
-    this._runtimeAgent.callFunctionOn(
-        this._objectId, functionDeclaration.toString(), args, true, true, false, undefined, undefined, mycallback);
+    this._runtimeAgent
+        .invoke_callFunctionOn({
+          objectId: this._objectId,
+          functionDeclaration: functionDeclaration.toString(),
+          arguments: args,
+          silent: true,
+          returnByValue: true
+        })
+        .then(
+            response => callback(response[Protocol.Error] || response.exceptionDetails ? null : response.result.value));
   }
 
   /**
    * @override
    */
   release() {
     if (!this._objectId)
       return;
     this._runtimeAgent.releaseObject(this._objectId);
   }
@@ skipping 90 matching lines @@
     // Scope objects always fetch preview.
     generatePreview = true;
 
     super.doGetProperties(ownProperties, accessorPropertiesOnly, generatePreview, wrappedCallback.bind(this));
   }
 
   /**
    * @override
    * @param {!Protocol.Runtime.RemoteObject} result
    * @param {!Protocol.Runtime.CallArgument} argumentName
-   * @param {function(string=)} callback
+   * @return {!Promise<string|undefined>}
    */
-  doSetObjectPropertyValue(result, argumentName, callback) {
+  async doSetObjectPropertyValue(result, argumentName) {
     var name = /** @type {string} */ (argumentName.value);
     this.debuggerModel().setVariableValue(
         this._scopeRef.number, name, SDK.RemoteObject.toCallArgument(result), this._scopeRef.callFrameId,
         setVariableValueCallback.bind(this));
+    var callback;
+    return new Promise(resolve => callback = resolve);
 
     /**
      * @param {string=} error
      * @this {SDK.ScopeRemoteObject}
      */
     function setVariableValueCallback(error) {
       if (error) {
         callback(error);
         return;
       }
@@ skipping 268 matching lines @@
    * @override
    * @return {number}
    */
   arrayLength() {
     return Array.isArray(this._value) ? this._value.length : 0;
   }
 
   /**
    * @override
    * @param {function(this:Object, ...)} functionDeclaration
-   * @param {!Array.<!Protocol.Runtime.CallArgument>=} args
+   * @param {!Array<!Protocol.Runtime.CallArgument>=} args
    * @param {function(?SDK.RemoteObject, boolean=)=} callback
    */
   callFunction(functionDeclaration, args, callback) {
     var target = /** @type {?Object} */ (this._value);
-    var rawArgs = args ? args.map(function(arg) {
-      return arg.value;
-    }) :
-                         [];
+    var rawArgs = args ? args.map(arg => arg.value) : [];
 
     var result;
     var wasThrown = false;
     try {
       result = functionDeclaration.apply(target, rawArgs);
     } catch (e) {
       wasThrown = true;
     }
 
     if (!callback)
       return;
     callback(SDK.RemoteObject.fromLocalObject(result), wasThrown);
   }
 
   /**
    * @override
    * @param {function(this:Object)} functionDeclaration
-   * @param {!Array.<!Protocol.Runtime.CallArgument>|undefined} args
+   * @param {!Array<!Protocol.Runtime.CallArgument>|undefined} args
    * @param {function(*)} callback
    */
   callFunctionJSON(functionDeclaration, args, callback) {
     var target = /** @type {?Object} */ (this._value);
-    var rawArgs = args ? args.map(function(arg) {
-      return arg.value;
-    }) :
-                         [];
+    var rawArgs = args ? args.map(arg => arg.value) : [];
 
     var result;
     try {
       result = functionDeclaration.apply(target, rawArgs);
     } catch (e) {
       result = null;
     }
 
     callback(result);
   }
@@ skipping 190 matching lines @@
  * @const
  * @type {!RegExp}
  */
 SDK.RemoteObject._descriptionLengthParenRegex = /\(([0-9]+)\)/;
 
 /**
  * @const
  * @type {!RegExp}
  */
 SDK.RemoteObject._descriptionLengthSquareRegex = /\[([0-9]+)\]/;