[DevTools] Support JQuery event listeners

Source/devtools/front_end/framework_support/EventListeners.js

Index: Source/devtools/front_end/framework_support/EventListeners.js
diff --git a/Source/devtools/front_end/framework_support/EventListeners.js b/Source/devtools/front_end/framework_support/EventListeners.js
new file mode 100644
index 0000000000000000000000000000000000000000..f6b602e16641b9a84de4908b2f6c78430d72b294
--- /dev/null
+++ b/Source/devtools/front_end/framework_support/EventListeners.js
@@ -0,0 +1,129 @@
+/*
+ * Copyright 2015 The Chromium Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+WebInspector.EventListenersFrameworkSupport = {}
+
+WebInspector.EventListenersFrameworkSupport._frameworkSupportInitializedSymbol = Symbol("frameworkSupportInitialized");
+
+/**
+ * @param {?WebInspector.ExecutionContext} context
+ * @return {!Promise<void>}
+ */
+WebInspector.EventListenersFrameworkSupport.initializeOnContext = function(context)
+{
+    return new Promise(initializeFrameworksSupport);
+
+    /**
+     * @param {function(?)} fulfill
+     * @param {function(*)} reject
+     */
+    function initializeFrameworksSupport(fulfill, reject)
+    {
+        var initializeFunction = ["(function(){",
+                                  initializeFrameworkUserEventListeners.toString(),
+                                  "initializeFrameworkUserEventListeners();",
+                                  initializeFrameworkInternalEventHandlers.toString(),
+                                  "initializeFrameworkInternalEventHandlers();",
+                                  "})();"].join("\n");
+        if (!context) {
+            reject("Empty context");
+            return;
+        }
+        if (WebInspector.EventListenersFrameworkSupport._frameworkSupportInitializedSymbol in context) {
+            fulfill(undefined);
+            return;
+        }
+        context[WebInspector.EventListenersFrameworkSupport._frameworkSupportInitializedSymbol] = true;
+        context.evaluate(initializeFunction, "EventListenersFrameworkSupport", false, true, true, false, fulfill);
+    }
+}
+
+function initializeFrameworkUserEventListeners()
+{
+    // We should call this function once per context.
+    self.devtoolsFrameworkUserEventListeners = self.devtoolsFrameworkUserEventListeners || [];

[paulirish, 2015/08/14 21:03:16]

self.devtoolsFrameworkEventListeners

I understand the distinction by putting "User" in there, but we can simplify by
leaving it out. 
Plus, if the frameworks themselves are binding to elements, it will resolve to a
different location than their addEventListener location anyhow.

+    self.devtoolsFrameworkUserEventListeners.push(jQueryUserEventListeners);
+
+    /**
+     * @param {!Object} node
+     * @return {!Array<!{type: string, listener: function(), useCapture: boolean}>}
+     */
+    function jQueryUserEventListeners(node)
+    {
+        if (!(node instanceof Node))
+            return [];
+        var hasJQuery = (typeof jQuery !== 'undefined') && jQuery.fn;
+        if (!hasJQuery)
+            return [];
+        var listeners = [];
+        var data = jQuery._data || jQuery.data;
+        if (typeof data === "function") {
+            var events = data(node, "events");
+            for (var type in events) {
+                for (var key in events[type]) {
+                    var frameworkListener = events[type][key];
+                    if (typeof frameworkListener === "object" || typeof frameworkListener === "function") {
+                        var listener = {
+                            handler: frameworkListener.handler || frameworkListener,
+                            useCapture: true,
+                            type: type
+                        };
+                        listeners.push(listener);
+                    }
+                }
+            }
+        }
+        var entry = jQuery(node)[0];
+        if (entry) {
+            var entryEvents = entry["$events"];
+            for (var type in entryEvents) {
+                var events = entryEvents[type];
+                for (var key in events) {
+                    if (typeof events[key] === "function") {
+                        var listener = {
+                            handler: events[key],
+                            useCapture: true,
+                            type: type
+                        };
+                        listeners.push(listener);
+                    }
+                }
+            }
+        }
+        return listeners;
+    }
+}
+
+function initializeFrameworkInternalEventHandlers()
+{
+    // We should call this function once per context.
+    self.devtoolsFrameworkInternalEventHandlers = self.devtoolsFrameworkInternalEventHandlers || [];
+    self.devtoolsFrameworkInternalEventHandlers.push(jQueryInternalEventHandlers);
+
+    /**
+     * @param {!Object} node
+     * @return {!Array<function()>}
+     */
+    function jQueryInternalEventHandlers(node)
+    {
+        if (!(node instanceof Node))
+            return [];
+        var hasJQuery = (typeof jQuery !== 'undefined') && jQuery.fn;
+        if (!hasJQuery)
+            return [];
+        var handlers = [];
+        var data = jQuery._data || jQuery.data;
+        if (typeof data === "function") {
+            var nodeData = data(node);
+            if (typeof nodeData.handle === "function")
+                handlers.push(nodeData.handle);
+        }
+        var entry = jQuery(node)[0];
+        if (entry && entry["$handle"])
+            handlers.push(entry["$handle"]);
+        return handlers;
+    }
+}