DevTools: Use JS symbols instead of strings for eligible events.

third_party/WebKit/Source/devtools/front_end/common/Object.js

 /*
  * Copyright (C) 2008 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 15 matching lines @@
 /**
  * @constructor
  * @implements {WebInspector.EventTarget}
  */
 WebInspector.Object = function() {
 }
 
 WebInspector.Object.prototype = {
     /**
      * @override
-     * @param {string} eventType
+     * @param {string|symbol} eventType
      * @param {function(!WebInspector.Event)} listener
      * @param {!Object=} thisObject
      * @return {!WebInspector.EventTarget.EventDescriptor}
      */
     addEventListener: function(eventType, listener, thisObject)
     {
         if (!listener)
             console.assert(false);
 
         if (!this._listeners)
             this._listeners = new Map();
         if (!this._listeners.has(eventType))
             this._listeners.set(eventType, []);
         this._listeners.get(eventType).push({ thisObject: thisObject, listener: listener });
         return new WebInspector.EventTarget.EventDescriptor(this, eventType, thisObject, listener);
     },
 
     /**
      * @override
-     * @param {string} eventType
+     * @param {string|symbol} eventType
      * @param {function(!WebInspector.Event)} listener
      * @param {!Object=} thisObject
      */
     removeEventListener: function(eventType, listener, thisObject)
     {
         console.assert(listener);
 
         if (!this._listeners || !this._listeners.has(eventType))
             return;
         var listeners = this._listeners.get(eventType);
         for (var i = 0; i < listeners.length; ++i) {
             if (listeners[i].listener === listener && listeners[i].thisObject === thisObject)
                 listeners.splice(i--, 1);
         }
 
         if (!listeners.length)
             this._listeners.delete(eventType);
     },
 
     /**
      * @override
      */
     removeAllListeners: function()
     {
         delete this._listeners;
     },
 
     /**
      * @override
-     * @param {string} eventType
+     * @param {string|symbol} eventType
      * @return {boolean}
      */
     hasEventListeners: function(eventType)
     {
-        if (!this._listeners || !this._listeners.has(eventType))
-            return false;
-        return true;
+        return this._listeners && this._listeners.has(eventType);
     },
 
     /**
      * @override
-     * @param {string} eventType
+     * @param {string|symbol} eventType
      * @param {*=} eventData
      * @return {boolean}
      */
     dispatchEventToListeners: function(eventType, eventData)
     {
         if (!this._listeners || !this._listeners.has(eventType))
             return false;
 
         var event = new WebInspector.Event(this, eventType, eventData);
         var listeners = this._listeners.get(eventType).slice(0);
         for (var i = 0; i < listeners.length; ++i) {
             listeners[i].listener.call(listeners[i].thisObject, event);
             if (event._stoppedPropagation)
                 break;
         }
 
         return event.defaultPrevented;
     }
 }
 
 /**
  * @constructor
  * @param {!WebInspector.EventTarget} target
- * @param {string} type
+ * @param {string|symbol} type
  * @param {*=} data
  */
 WebInspector.Event = function(target, type, data)
 {
     this.target = target;
     this.type = type;
     this.data = data;
     this.defaultPrevented = false;
     this._stoppedPropagation = false;
 }
@@ skipping 33 matching lines @@
 WebInspector.EventTarget.removeEventListeners = function(eventList)
 {
     for (var i = 0; i < eventList.length; ++i) {
         var eventInfo = eventList[i];
         eventInfo.eventTarget.removeEventListener(eventInfo.eventType, eventInfo.method, eventInfo.receiver);
     }
 }
 
 WebInspector.EventTarget.prototype = {
     /**
-     * @param {string} eventType
+     * @param {string|symbol} eventType
      * @param {function(!WebInspector.Event)} listener
      * @param {!Object=} thisObject
      * @return {!WebInspector.EventTarget.EventDescriptor}
      */
     addEventListener: function(eventType, listener, thisObject) { },
 
     /**
-     * @param {string} eventType
+     * @param {string|symbol} eventType
      * @param {function(!WebInspector.Event)} listener
      * @param {!Object=} thisObject
      */
     removeEventListener: function(eventType, listener, thisObject) { },
 
     removeAllListeners: function() { },
 
     /**
-     * @param {string} eventType
+     * @param {string|symbol} eventType
      * @return {boolean}
      */
     hasEventListeners: function(eventType) { },
 
     /**
-     * @param {string} eventType
+     * @param {string|symbol} eventType
      * @param {*=} eventData
      * @return {boolean}
      */
     dispatchEventToListeners: function(eventType, eventData) { },
 }
 
 /**
  * @constructor
  * @param {!WebInspector.EventTarget} eventTarget
- * @param {string} eventType
+ * @param {string|symbol} eventType
  * @param {(!Object|undefined)} receiver
  * @param {function(?):?} method
  */
 WebInspector.EventTarget.EventDescriptor = function(eventTarget, eventType, receiver, method)
 {
     this.eventTarget = eventTarget;
     this.eventType = eventType;
     this.receiver = receiver;
     this.method = method;
 }