Add ability to toggle passive state on an individual event listener.

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

Index: third_party/WebKit/Source/devtools/front_end/sdk/RemoteObject.js
diff --git a/third_party/WebKit/Source/devtools/front_end/sdk/RemoteObject.js b/third_party/WebKit/Source/devtools/front_end/sdk/RemoteObject.js
index db5021ec290bf34878827f1fb7c43ee639d19fb8..69c190cebbf092d89ef5d361b34203a5886536d3 100644
--- a/third_party/WebKit/Source/devtools/front_end/sdk/RemoteObject.js
+++ b/third_party/WebKit/Source/devtools/front_end/sdk/RemoteObject.js
@@ -562,6 +562,9 @@ WebInspector.RemoteObjectImpl.prototype = {
             /** @type {?WebInspector.RemoteObject} */
             var removeFunction = null;
 
+            /** @type {?WebInspector.RemoteObject} */
+            var togglePassiveFunction = null;
+
             this.callFunctionPromise(nodeRemoveEventListener).then(storeRemoveFunction.bind(this));
 
             /**
@@ -572,6 +575,19 @@ WebInspector.RemoteObjectImpl.prototype = {
             {
                 if (!result.wasThrown && result.object)
                     removeFunction = result.object;
+
+                this.callFunctionPromise(nodeTogglePassiveEventListener).then(storeTogglePassiveFunction.bind(this));

[caseq, 2016/06/01 17:48:11]

I think this is getting a bit too complicated. Actually, I think this was more
complicated than necessary originally -- adding Alexey since he's the owner of
this code. Basically, we do a round-trip to the front-end to inject a wrapper
function that would only be called in a somewhat unlikely event of user pressing
the "remove" button, and you're now adding another round-trip. What we could do
instead is to do the same lazily upon remove/togglePassive being called. I think
this would also simplify actual injected script by removing extra indirection in
the form of nested function that gets bound.

[dtapuska, 2016/06/01 17:54:37]

I completely agree. I tried passing back an array of bound functions but that
didn't work. I was a little unclear why it was done this way. I wondered if it
was because of framework listeners. It isn't clear to me why you can't just call
it to execute a remote function when you goto remove.

[kozy, 2016/06/01 19:05:01]

It was added here to align implementation for native event listeners with
framework event listeners. Since we moved Command Line API getEventListeners
method into native, now we can add removeFunction to protocol EventListener
object and report this from backend without roundtrip. It will simplify this
code. I can prepare CL for this.
For toggling passive event listeners it's better to call this function on node
when user click toggle button with RemoteObject.callFunctionOn method.

[dtapuska, 2016/06/01 20:22:58]

Do you mean just calling this from EventListenersView? 

I'd expect that togglePassive be a function on WebInspector.EventListener and it
would invoke the code on the target's remote Object. However it appears that the
target on the WebInspector.EventListener isn't a RemoteObject but a
WebInspector.Target

+            }
+
+            /**
+             * @param {!WebInspector.CallFunctionResult} result
+             * @this {WebInspector.RemoteObject}
+             */
+            function storeTogglePassiveFunction(result)
+            {
+                if (!result.wasThrown && result.object)
+                    togglePassiveFunction = result.object;
+
                 this.target().domdebuggerAgent().getEventListeners(this._objectId, mycallback.bind(this));
             }
 
@@ -628,6 +644,39 @@ WebInspector.RemoteObjectImpl.prototype = {
             }
 
             /**
+             * @suppressReceiverCheck
+             * @this {Node}
+             * @return {function(this:Node, string, function(), boolean, boolean): undefined}
+             */
+            function nodeTogglePassiveEventListener()
+            {
+                return togglePassiveListenerWrapper.bind(this);
+                /**
+                 * @param {string} type
+                 * @param {function()} handler
+                 * @param {boolean} useCapture
+                 * @param {boolean} passive
+                 * @this {Node}
+                 */
+                function togglePassiveListenerWrapper(type, handler, useCapture, passive)
+                {
+                    // TODO(dtapuska): Remove this one closure compiler is updated
+                    // to handle EventListenerOptions and passive event listeners
+                    // has shipped. Don't JSDoc these otherwise it will fail.
+                    // @return {{capture: boolean, passive: boolean}}
+                    function eventListenerOptions()
+                    {
+                        return {"capture": useCapture, "passive": passive};
+                    }
+                    this.removeEventListener(type, handler, eventListenerOptions());
+                    passive = !passive;
+                    this.addEventListener(type, handler, eventListenerOptions());
+                    if (this["on" + type])
+                        this["on" + type] = null;

[caseq, 2016/06/01 17:48:11]

Not sure if this is something you want to do on toggle.

[dtapuska, 2016/06/02 16:02:11]

Acknowledged.

+                }
+            }
+
+            /**
              * @this {!WebInspector.RemoteObject}
              * @param {!DOMDebuggerAgent.EventListener} payload
              */
@@ -640,7 +689,8 @@ WebInspector.RemoteObjectImpl.prototype = {
                                                       payload.handler ? this.target().runtimeModel.createRemoteObject(payload.handler) : null,
                                                       payload.originalHandler ? this.target().runtimeModel.createRemoteObject(payload.originalHandler) : null,
                                                       WebInspector.DebuggerModel.Location.fromPayload(this._debuggerModel, payload.location),
-                                                      removeFunction);
+                                                      removeFunction,
+                                                      togglePassiveFunction);
             }
         }
     },