[DevTools] Support JQuery event listeners

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 11 matching lines @@
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 /**
+ * @typedef {{object: ?WebInspector.RemoteObject, wasThrown: (boolean|undefined)}}
+ */
+WebInspector.CallFunctionResult;
+
+/**
  * This may not be an interface due to "instanceof WebInspector.RemoteObject" checks in the code.
  *
  * @constructor
  */
 WebInspector.RemoteObject = function() { }
 
 WebInspector.RemoteObject.prototype = {
 
     /**
      * @return {?RuntimeAgent.CustomPreview}
@@ skipping 115 matching lines @@
 
     /**
      * @return {!Promise<?Array<!WebInspector.EventListener>>}
      */
     eventListeners: function()
     {
         throw "Not implemented";
     },
 
     /**
+     * @param {function(this:Object):!Array<!{handler:function(), useCapture: boolean, type:string}>} getter
+     * @return {!Promise<?Array<!WebInspector.EventListener>>}
+     */
+    frameworkEventListeners: function(getter)
+    {
+        throw "Not implemented";
+    },
+
+    /**
+     * @param {function(this:Object):!Array<function()>} getter
+     * @return {!Promise<?WebInspector.RemoteSet>}
+     */
+    frameworkInternalHandlers: function(getter)
+    {
+        throw "Not implemented";
+    },
+
+    /**
      * @param {!RuntimeAgent.CallArgument} name
      * @param {function(string=)} callback
      */
     deleteProperty: function(name, callback)
     {
         throw "Not implemented";
     },
 
     /**
      * @param {function(this:Object, ...)} functionDeclaration
      * @param {!Array.<!RuntimeAgent.CallArgument>=} args
      * @param {function(?WebInspector.RemoteObject, boolean=)=} callback
      */
     callFunction: function(functionDeclaration, args, callback)
     {
         throw "Not implemented";
     },
 
     /**
      * @param {function(this:Object, ...)} functionDeclaration
      * @param {!Array.<!RuntimeAgent.CallArgument>=} args
-     * @return {!Promise.<!{object: ?WebInspector.RemoteObject, wasThrown: (boolean|undefined)}>}
+     * @return {!Promise<!WebInspector.CallFunctionResult>}
      */
     callFunctionPromise: function(functionDeclaration, args)
     {
         return new Promise(promiseConstructor.bind(this));
 
         /**
-         * @param {function(!{object: ?WebInspector.RemoteObject, wasThrown: (boolean|undefined)})} success
+         * @param {function(!WebInspector.CallFunctionResult)} success
          * @this {WebInspector.RemoteObject}
          */
         function promiseConstructor(success)
         {
             this.callFunction(functionDeclaration, args, callFunctionCallback.bind(null, success));
         }
 
         /**
-         * @param {function(!{object: ?WebInspector.RemoteObject, wasThrown: (boolean|undefined)})} callback
+         * @param {function(!WebInspector.CallFunctionResult)} callback
          * @param {?WebInspector.RemoteObject} object
          * @param {boolean=} wasThrown
          */
         function callFunctionCallback(callback, object, wasThrown)
         {
             callback({
                 object: object,
                 wasThrown: wasThrown
             });
         }
     },
 
     /**
-     * @param {function(this:Object)} functionDeclaration
+     * @param {function(this:Object, ...)} functionDeclaration
      * @param {!Array<!RuntimeAgent.CallArgument>|undefined} args
      * @param {function(*)} callback
      */
     callFunctionJSON: function(functionDeclaration, args, callback)
     {
         throw "Not implemented";
     },
 
     /**
-     * @param {function(this:Object)} functionDeclaration
+     * @param {function(this:Object, ...)} functionDeclaration
      * @param {!Array<!RuntimeAgent.CallArgument>|undefined} args
      * @return {!Promise<*>}
      */
     callFunctionJSONPromise: function(functionDeclaration, args)
     {
         return new Promise(promiseConstructor.bind(this));
 
         /**
          * @this {WebInspector.RemoteObject}
          */
@@ skipping 319 matching lines @@
                 return new WebInspector.EventListener(this._target,
                                                       payload.type,
                                                       payload.useCapture,
                                                       payload.handler ? this.target().runtimeModel.createRemoteObject(payload.handler) : null,
                                                       WebInspector.DebuggerModel.Location.fromPayload(this._debuggerModel, payload.location));
             }
         }
     },
 
     /**
+     * @override
+     * @param {function(this:Object):!Array<!{handler:function(), useCapture: boolean, type:string}>} getter
+     * @return {!Promise<?Array<!WebInspector.EventListener>>}
+     */
+    frameworkEventListeners: function(getter)

[pfeldman, 2015/08/27 01:21:32]

This does not belong to RemoteObject, I thought we agreed on moving it to the
event listeners area.

+    {
+        return this.callFunctionPromise(getter, undefined)
+                   .then(WebInspector.assertCallFunctionResult)
+                   .then(WebInspector.RemoteArray.createPromise)
+                   .then(toEventListeners)
+                   .catchException(/** @type {?Array<!WebInspector.EventListener>} */(null));
+
+        /**
+         * @param {!WebInspector.RemoteArray} array
+         * @return {!Promise<?Array<!WebInspector.EventListener>>}
+         */
+        function toEventListeners(array)
+        {
+            var promises = [];
+            for (var i = 0; i < array.length(); ++i) {
+                var promise = array.at(i)
+                                   .then(WebInspector.assertCallFunctionResult)
+                                   .then(toEventListener)
+                                   .catchException(/** @type {?WebInspector.EventListener} */(null));
+                promises.push(promise);
+            }
+            return /** @type {!Promise<?Array<!WebInspector.EventListener>>} */(Promise.all(promises).then(nonEmptyListeners));
+        }
+
+        /**
+         * @param {!WebInspector.RemoteObject} object
+         * @return {!Promise<!WebInspector.EventListener>}
+         */
+        function toEventListener(object)
+        {
+            var data = {};
+            var promises = [];
+            promises.push(object.callFunctionPromise(listenerEffectiveFunction, undefined)
+                                .then(WebInspector.assertCallFunctionResult)
+                                .then(WebInspector.RemoteFunction.createPromise)
+                                .then(storeTargetFunctionWithDetails.bind(null, data)));
+            promises.push(object.callFunctionJSONPromise(WebInspector.identity, undefined)
+                                .then(WebInspector.storeTo.bind(null, data, "listenerJSON")));
+            return Promise.all(promises).then(createEventListener.bind(null, /** @type {!{targetFunction: !WebInspector.RemoteObject, listenerJSON: !Object, targetFunctionDetails: !WebInspector.DebuggerModel.FunctionDetails}}*/ (data)));
+        }
+
+        /**
+         * @param {?} data
+         * @param {!WebInspector.RemoteFunction} functionObject
+         * @return {!Promise<void>}
+         */
+        function storeTargetFunctionWithDetails(data, functionObject)
+        {
+            return functionObject.targetFunction()
+                                 .then(WebInspector.storeTo.bind(null, data, "targetFunction"))
+                                 .then(functionDetails);
+
+            /**
+             * @param {!WebInspector.RemoteObject} functionObject
+             * @return {!Promise<void>}
+             */
+            function functionDetails(functionObject)
+            {
+                return functionObject.functionDetailsPromise()
+                                     .then(WebInspector.storeTo.bind(null, data, "targetFunctionDetails"));
+            }
+        }
+
+        /**
+         * @param {!{targetFunction: !WebInspector.RemoteObject, listenerJSON: !Object, targetFunctionDetails: !WebInspector.DebuggerModel.FunctionDetails}} data
+         * @return {!WebInspector.EventListener}
+         */
+        function createEventListener(data)
+        {
+            return new WebInspector.EventListener(data.targetFunction._target,
+                                                  data.listenerJSON.type,
+                                                  data.listenerJSON.useCapture,
+                                                  data.targetFunction,
+                                                  /** @type {!WebInspector.DebuggerModel.Location}} */ (data.targetFunctionDetails.location));
+        }
+
+        /**
+         * @suppressReceiverCheck
+         * @return {function()}
+         * @this {Object}
+         */
+        function listenerEffectiveFunction()
+        {
+            if (typeof this.handler === "function")
+                return this.handler;
+            return typeof this.handler === "object" ? (this.handler.handlerEvent || this.handler.constructor) : null;
+        }
+
+        /**
+         * @param {!Array<?WebInspector.EventListener>} listeners
+         * @return {!Array<!WebInspector.EventListener>}
+         */
+        function nonEmptyListeners(listeners)
+        {
+            return listeners.filter(filterOutEmpty);
+
+            /**
+             * @param {?WebInspector.EventListener} listener
+             */
+            function filterOutEmpty(listener)
+            {
+                return !!listener;
+            }
+        }
+    },
+
+    /**
+     * @override
+     * @param {function(this:Object):!Array<function()>} getter
+     * @return {!Promise<?WebInspector.RemoteSet>}
+     */
+    frameworkInternalHandlers: function(getter)
+    {
+        return this.callFunctionPromise(getter, undefined)
+                   .then(WebInspector.assertCallFunctionResult)
+                   .then(WebInspector.RemoteArray.createPromise)
+                   .then(toInternalHandlers.bind(this))
+                   .catchException(/** @type {?WebInspector.RemoteSet} */(null));
+
+        /**
+         * @param {!WebInspector.RemoteArray} array
+         * @return {!Promise<!WebInspector.RemoteSet>}
+         * @this {WebInspector.RemoteObject}
+         */
+        function toInternalHandlers(array)
+        {
+            var promises = [];
+            for (var i = 0; i < array.length(); ++i) {
+                var promise = array.at(i)
+                                   .then(WebInspector.assertCallFunctionResult)
+                                   .then(WebInspector.RemoteFunction.createPromise)
+                                   .then(toInternalHandler)
+                                   .catchException(/** @type {?WebInspector.RemoteObject} */(null));
+                promises.push(promise);
+            }
+            return Promise.all(promises).then(nonEmptyHandlers).then(WebInspector.RemoteSet.createFromArrayPromise.bind(this));
+        }
+
+        /**
+         * @param {!WebInspector.RemoteFunction} handler
+         * @return {!Promise<!WebInspector.RemoteObject>}
+         */
+        function toInternalHandler(handler)
+        {
+            return handler.targetFunction();
+        }
+
+        /**
+         * @param {!Array<?WebInspector.RemoteObject>} handlers
+         * @return {!Array<!WebInspector.RemoteObject>}
+         */
+        function nonEmptyHandlers(handlers)
+        {
+            return handlers.filter(filterOutEmpty);
+
+            /**
+             * @param {?WebInspector.RemoteObject} handler
+             */
+            function filterOutEmpty(handler)
+            {
+                return !!handler;
+            }
+        }
+    },
+
+    /**
      * @param {!Array.<string>} propertyPath
      * @param {function(?WebInspector.RemoteObject, boolean=)} callback
      */
     getProperty: function(propertyPath, callback)
     {
         /**
          * @param {string} arrayStr
          * @suppressReceiverCheck
          * @this {Object}
          */
@@ skipping 777 matching lines @@
     {
         if (!this._cachedDescription) {
             var children = this._children();
             this._cachedDescription = "{" + this._formatValue(children[0].value) + " => " + this._formatValue(children[1].value) + "}";
         }
         return this._cachedDescription;
     },
 
     __proto__: WebInspector.LocalJSONObject.prototype
 }