Specs: Add a way for the inspector to see the registered event listeners

sky/specs/apis.md

-APIS
+APIs
 ====
 
 The Sky core API
 ----------------
 
 ```javascript
 module 'sky:core' {
 
   // EVENTS
 
@@ skipping 10 matching lines @@
     // TODO(ianh): do events get blocked at scope boundaries, e.g. focus events when both sides are in the scope?
     // TODO(ianh): do events ger retargetted, e.g. focus when leaving a custom element?
   }
 
   callback EventListener any (Event event); // return value is assigned to Event.result
 
   interface EventTarget {
     any dispatchEvent(Event event); // O(N) in total number of listeners for this type in the chain // returns Event.result
     void addEventListener(String type, EventListener listener); // O(1)
     void removeEventListener(String type, EventListener listener); // O(N) in event listeners with that type
+    private Array<String> getRegisteredEventListenerTypes(); // O(N)
+    private Array<EventListener> getRegisteredEventListenersForType(String type); // O(N)
   }
 
   interface CustomEventTarget : EventTarget {
     constructor (); // O(1)
     attribute EventTarget parentNode; // getter O(1), setter O(N) in height of tree, throws if this would make a loop
 
     // you can inherit from this to make your object into an event target
   }
 
 
@@ skipping 206 matching lines @@
     ReturnType method();
       // When the platform calls this method, it always invokes the "real" method, even if it's been
       // deleted from the prototypes (as if it took a reference to the method at startup, and stored
       // state using Symbols)
     virtual ReturnType methodCallback();
       // when the platform calls this, it actually calls it the way JS would, so author overrides do
       // affect what gets called. Make sure if you override it that you call the superclass implementation!
       // The default implementations of 'virtual' methods all end by calling the identically named method
       // on the superclass, if there is such a method.
 
+    // private APIs - see below
+    private void method();
+
     // arguments and overloading are done as follows
     // note that the argument names are only for documentation purposes
     ReturnType method(ArgumentType argumentName1, ArgumentType argumentName2);
     // the last argument's type can have "..." appended to it to indicate a varargs-like situation
     ReturnType method(ArgumentType argumentName1, ArgumentType... allSubsequentArguments);
   }
 
   // the module can have properties and methods also
   attribute String Foo;
   void method();
 
 }
 ```
 
+### Private APIs ###
+
+Private APIs are only accessible via Symbol objects, which are then
+exposed on the sky:debug module's exports object as the name of the
+member given in the IDL.
+
+For example, consider:
+
+```javascript
+interface Foo {
+  private void Bar();
+}
+```
+
+In a script with a ``foo`` object of type ``Foo``, ``foo.Bar`` is
+undefined. However, it can be obtained as follows:
+
+```html
+<import src="sky:debug" as="debug"/>
+<!-- ... import whatever defines 'foo' ... -->
+<script>
+  foo[debug.Bar]
+</script>
+```
+
+### Types ###
+
 The following types are available:
 
 * ``Integer`` - WebIDL ``long long``
 * ``Float`` - WebIDL ``double``
 * ``String`` - WebIDL ``USVString``
 * ``Boolean`` - WebIDL ``boolean``
 # ``Object`` - WebIDL ``object``
 * ``InterfaceName`` - an instance of the interface InterfaceName
 * ``Promise<Type>`` - WebIDL ``Promise<T>``
 * ``Array<Type>`` - WebIDL ``sequence<T>``
 * ``Dictionary`` - unordered set of name-value String-String pairs with no duplicate names
 * ``Type?`` - union of Type and the singleton type with value "null" (WebIDL nullable)
 * ``(Type1 or Type2)`` - union of Type1 and Type2 (WebIDL union)
 * ``any`` - union of all types (WebIDL ``any``)
 
 Methods that return nothing (undefined, in JS) use the keyword "void"
 instead of a type.
 
 TODO(ianh): Figure out what should happen with omitted and extraneous parameters
 
 TODO(ianh): Define in detail how this actually works
 
+
 Mojom IDL
 ---------
 
 The Mojom IDL language is used to describe the APIs exposed over Mojo
 pipes.
 
 Mojom IDL definitions are typically compiled to wrappers in each
 language, which are then used as imports.
 
 TODO(ianh): Define in detail how this actually works
 
 
 Notes
 -----
 ```javascript
 global object = {} // with Math, RegExp, etc
 
 magical imports:
   the core mojo fabric JS API   sky:mojo:fabric:core
   the asyncWait/cancelWait mojo fabric JS API (interface to IPC thread)  sky:mojo:fabric:ipc
   the mojom for the shell, proxying through C++ so that the shell pipe isn't exposed  sky:mojo:shell
   the sky API  sky:core
+  the sky debug symbols for private APIs  sky:debug
 ```
 
 TODO(ianh): determine if we want to separate the "this" from the
 Document, especially for Modules, so that exposing a module's element
 doesn't expose the module's exports attribute.