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

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 544 matching lines @@
             }
 
             if (!this._objectId) {
                 reject(null);
                 return;
             }
 
             /** @type {?WebInspector.RemoteObject} */
             var removeFunction = null;
 
+            /** @type {?WebInspector.RemoteObject} */
+            var togglePassiveFunction = null;
+
             this.callFunctionPromise(nodeRemoveEventListener).then(storeRemoveFunction.bind(this));
 
             /**
              * @param {!WebInspector.CallFunctionResult} result
              * @this {WebInspector.RemoteObject}
              */
             function storeRemoveFunction(result)
             {
                 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));
             }
 
             /**
              * @this {!WebInspector.RemoteObject}
              * @param {?Protocol.Error} error
              * @param {!Array<!DOMDebuggerAgent.EventListener>} payloads
              */
             function mycallback(error, payloads)
             {
@@ skipping 36 matching lines @@
                         else
                             return {};
                     }
                     this.removeEventListener(type, handler, eventListenerOptions());
                     if (this["on" + type])
                         this["on" + type] = null;
                 }
             }
 
             /**
+             * @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
              */
             function createEventListener(payload)
             {
                 return new WebInspector.EventListener(this._target,
                                                       payload.type,
                                                       payload.useCapture,
                                                       payload.passive,
                                                       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);
             }
         }
     },
 
     /**
      * @param {!Array.<string>} propertyPath
      * @param {function(?WebInspector.RemoteObject, boolean=)} callback
      */
     getProperty: function(propertyPath, callback)
     {
@@ skipping 1005 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
 }