# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.

# DOM Bindings Configuration.
#
# The WebIDL interfaces are defined in dom/webidl. For each such interface, there
# is a corresponding entry in the configuration table below. The configuration
# table maps each interface name to a |descriptor| or list of |descriptor|s.
#
# Valid fields for all descriptors:
#   * nativeType - The native type (concrete class or XPCOM interface) that
#                  instances of this interface will unwrap to.  If not
#                  specified, defaults to 'mozilla::dom::InterfaceName' for
#                  non-worker non-external-or-callback interfaces, to
#                  'mozilla::dom::workers::InterfaceName' for worker
#                  non-external interfaces, to 'nsIDOM' followed by the
#                  interface name for non-worker external-or-callback
#                  interfaces, and to 'JSObject' for worker external-or-callback
#                  interfaces.
#   * headerFile - The file in which the nativeType is declared (defaults
#                  to an educated guess).
#   * concrete - Indicates whether there exist JS objects with this interface as
#                their primary interface (and hence whose prototype is this
#                interface's prototype object).  Always False for callback
#                interfaces.  Defaults to True otherwise.
#   * workers - Indicates whether the descriptor is intended to be used solely
#               for worker threads (defaults to false). If true the interface
#               will not be made available on the main thread.
#   * notflattened - The native type does not have nsIClassInfo, so when
#                    wrapping it the right IID needs to be passed in.
#   * register - True if this binding should be registered.  Defaults to true.
#   * binaryNames - Dict for mapping method and attribute names to different
#                   names when calling the native methods (defaults to an empty
#                   dict). The keys are the property names as they appear in the
#                   .webidl file and the values are the names as they should be
#                   in the WebIDL.
#   * wrapperCache: True if this object is a wrapper cache.  Objects that are
#                   not can only be returned from a limited set of methods,
#                   cannot be prefable, and must ensure that they disallow
#                   XPConnect wrapping.  Always false for callback interfaces.
#                   Always true for worker descriptors for non-callback
#                   interfaces.  Defaults to true for non-worker non-callback
#                   descriptors.
#   * nativeOwnership: Describes how the native object is held. 3 possible
#                      types: worker object ('worker'), non-refcounted object
#                      ('owned'), refcounted object ('refcounted').
#                      Non-refcounted objects need to inherit from
#                      mozilla::dom::NonRefcountedDOMObject and preferably use
#                      MOZ_COUNT_CTOR/MOZ_COUNT_DTOR in their
#                      constructor/destructor so they participate in leak
#                      logging.
#                      This mostly determines how the finalizer releases the
#                      binding's hold on the native object. For a worker object
#                      it'll call Release, for a non-refcounted object it'll
#                      call delete through XPConnect's deferred finalization
#                      mechanism, for a refcounted object it'll call Release
#                      through XPConnect's deferred finalization mechanism.
#                      'worker' opts into old style worker models. Defaults to
#                      'refcounted'.
#
#   The following fields are either a string, an array (defaults to an empty
#   array) or a dictionary with three possible keys (all, getterOnly and
#   setterOnly) each having such an array as the value
#
#   * implicitJSContext - attributes and methods specified in the .webidl file
#                         that require a JSContext as the first argument
#   * resultNotAddRefed - attributes and methods specified in the .webidl file
#                         that do not AddRef the return value
#
# A descriptor can also have 'skipGen': True specified if it should be skipped
# when deciding what header includes to generate and should never have an
# implementation generated for it.  This is only needed in special cases like
# worker descriptors for objects that will never actually appear in workers.
#
# The value for an interface can be a list or a dictionary, which affects which
# bindings are generated for that interface.
# - If the value for the interface is just a record, then a single binding for
#   will be generated using those settings.
# - If it is a list with a single record which has 'workers':True, then that
#   record will be used to generate bindings for workers, plus the default
#   settings will be used to generate bindings for the main thread.
# - If it is a list with two records, then one should have 'workers':True,
#   and the other should have 'workers':False (or left unset). These will
#   be used to generate bindings for workers and for mainthread, as you would
#   expect.
# Nothing else is allowed.  If you have a list with a single 'workers':False
# entry, just make it not a list.

DOMInterfaces = {

'MozActivity': {
    'nativeType': 'mozilla::dom::Activity',
},

'AbstractWorker': {
    'concrete': False
},

'ArchiveReader': {
    'nativeType': 'mozilla::dom::file::ArchiveReader',
},

'ArchiveRequest': {
    'nativeType': 'mozilla::dom::file::ArchiveRequest',
},

'AudioChannelManager': {
    'nativeType': 'mozilla::dom::system::AudioChannelManager',
    'headerFile': 'AudioChannelManager.h'
},

'AudioContext': {
    'implicitJSContext': [ 'createBuffer' ],
    'resultNotAddRefed': [ 'destination', 'listener' ],
},

'AudioBuffer': {
    'implicitJSContext': [ 'copyToChannel' ],
},

'AudioBufferSourceNode': {
    'implicitJSContext': [ 'buffer' ],
    'resultNotAddRefed': [ 'playbackRate' ],
},

'AudioNode' : {
    'concrete': False,
    'binaryNames': {
        'channelCountMode': 'channelCountModeValue',
        'channelInterpretation': 'channelInterpretationValue',
    },
},

'AudioProcessingEvent' : {
    'resultNotAddRefed': [ 'inputBuffer', 'outputBuffer' ],
},

'BarProp': {
    'headerFile': 'mozilla/dom/BarProps.h',
},

'BiquadFilterNode': {
    'resultNotAddRefed': [ 'frequency', 'detune', 'q', 'gain' ],
},

'Blob': [
{
    'headerFile': 'nsIDOMFile.h',
},
{
    'workers': True,
}],

'BatteryManager': {
    'nativeType': 'mozilla::dom::battery::BatteryManager',
    'headerFile': 'BatteryManager.h'
},

'BluetoothAdapter': {
    'nativeType': 'mozilla::dom::bluetooth::BluetoothAdapter',
    'headerFile': 'BluetoothAdapter.h'
},

'BluetoothDevice': {
    'nativeType': 'mozilla::dom::bluetooth::BluetoothDevice',
    'headerFile': 'BluetoothDevice.h'
},

'BluetoothManager': {
    'nativeType': 'mozilla::dom::bluetooth::BluetoothManager',
    'headerFile': 'BluetoothManager.h'
},

'CameraCapabilities': {
    'nativeType': 'mozilla::dom::CameraCapabilities',
    'headerFile': 'DOMCameraCapabilities.h'
},

'CameraControl': {
    'nativeType': 'mozilla::nsDOMCameraControl',
    'headerFile': 'DOMCameraControl.h',
    'binaryNames': {
        "release": "ReleaseHardware"
    }
},

'CameraDetectedFace': {
    'nativeType': 'mozilla::dom::DOMCameraDetectedFace',
    'headerFile': 'DOMCameraDetectedFace.h'
},

'CameraManager': {
    'nativeType': 'nsDOMCameraManager',
    'headerFile': 'DOMCameraManager.h'
},

'CameraPoint': {
    'nativeType': 'mozilla::dom::DOMCameraPoint',
    'headerFile': 'DOMCameraDetectedFace.h'
},

'CanvasRenderingContext2D': {
    'implicitJSContext': [
        'createImageData', 'getImageData', 'isPointInPath', 'isPointInStroke'
    ],
    'resultNotAddRefed': [ 'canvas', 'measureText' ],
    'binaryNames': {
        'mozImageSmoothingEnabled': 'imageSmoothingEnabled',
        'mozFillRule': 'fillRule'
    }
},

'CaretPosition' : {
    'nativeType': 'nsDOMCaretPosition',
},

'CharacterData': {
    'nativeType': 'nsGenericDOMDataNode',
    'concrete': False
},

'ChromeWindow': {
    'concrete': False,
    'register': False,
},

'ChromeWorker': {
    'headerFile': 'mozilla/dom/WorkerPrivate.h',
    'nativeType': 'mozilla::dom::workers::ChromeWorkerPrivate',
},

'Console': {
    'implicitJSContext': [ 'trace', 'time', 'timeEnd' ],
},

'ConvolverNode': {
    'implicitJSContext': [ 'buffer' ],
    'resultNotAddRefed': [ 'buffer' ],
},

'Coordinates': {
    'headerFile': 'nsGeoPosition.h'
},

'CRMFObject': {
    'headerFile': 'nsCrypto.h',
    'nativeOwnership': 'owned',
    'wrapperCache': False,
},

'Crypto' : {
    'implicitJSContext': [ 'generateCRMFRequest', 'signText' ],
    'headerFile': 'Crypto.h'
},

'CSS': {
    'concrete': False,
},

'CSS2Properties': {
    'nativeType': 'nsDOMCSSDeclaration'
},

'CSSPrimitiveValue': {
    'nativeType': 'nsROCSSPrimitiveValue',
    'resultNotAddRefed': ['getRGBColorValue', 'getRectValue']
},

'CSSStyleDeclaration': {
    'nativeType': 'nsICSSDeclaration'
},

'CSSStyleSheet': {
    'nativeType': 'nsCSSStyleSheet',
    'binaryNames': { 'ownerRule': 'DOMOwnerRule' },
},

'CSSValue': {
    'concrete': False
},

'CSSValueList': {
    'nativeType': 'nsDOMCSSValueList'
},

'DataChannel': {
    'nativeType': 'nsDOMDataChannel',
},

'DataStoreCursor': {
    'wrapperCache': False,
},

'DedicatedWorkerGlobalScope': {
    'headerFile': 'mozilla/dom/WorkerScope.h',
    'workers': True,
},

'DelayNode': {
    'resultNotAddRefed': [ 'delayTime' ],
},

'DeviceAcceleration': {
    'headerFile': 'mozilla/dom/DeviceMotionEvent.h',
},

'DeviceRotationRate': {
    'headerFile': 'mozilla/dom/DeviceMotionEvent.h',
},

'DeviceStorage': {
    'nativeType': 'nsDOMDeviceStorage',
    'headerFile': 'DeviceStorage.h',
},

'Document': [
{
    'nativeType': 'nsIDocument',
    'resultNotAddRefed': [ 'implementation', 'doctype', 'documentElement',
                           'getElementById', 'adoptNode', 'defaultView',
                           'activeElement', 'currentScript',
                           'mozFullScreenElement', 'mozPointerLockElement',
                           'styleSheets', 'styleSheetSets', 'elementFromPoint',
                           'querySelector', 'getAnonymousNodes',
                           'getAnonymousElementByAtribute', 'getBindingParent'
                           ],
    'binaryNames': {
        'documentURI': 'documentURIFromJS',
        'URL': 'documentURIFromJS'
    }
},
{
    'nativeType': 'JSObject',
    'workers': True,
    'skipGen': True
}],

'DocumentFragment': {
    'resultNotAddRefed': [ 'querySelector' ]
},

'DOMException': {
    'binaryNames': {
        'message': 'messageMoz',
    },
},

'DOMPointReadOnly': {
    'headerFile': 'mozilla/dom/DOMPoint.h',
    'concrete': False,
},

'DOMRectList': {
    'headerFile': 'mozilla/dom/DOMRect.h',
    'resultNotAddRefed': [ 'item' ]
},

'DOMRectReadOnly': {
    'headerFile': 'mozilla/dom/DOMRect.h',
},

'DOMQuad': {
    'resultNotAddRefed': [ 'bounds', 'p0', 'p1', 'p2', 'p3' ]
},

'DOMSettableTokenList': {
    'nativeType': 'nsDOMSettableTokenList',
},

'DOMStringMap': {
    'nativeType': 'nsDOMStringMap'
},

'DOMTokenList': {
    'nativeType': 'nsDOMTokenList',
},

'DummyInterface': {
    'skipGen': True,
    'register': False,
},

'DummyInterfaceWorkers': {
    'skipGen': True,
    'register': False,
    'workers': True
},

'DynamicsCompressorNode': {
    'resultNotAddRefed': [ 'threshold', 'knee', 'ratio',
                           'reduction', 'attack', 'release' ],
    'binaryNames': {
        'release': 'getRelease'
    },
},

'Element': {
    'resultNotAddRefed': [
        'classList', 'attributes', 'children', 'firstElementChild',
        'lastElementChild', 'previousElementSibling', 'nextElementSibling',
        'getAttributeNode', 'getAttributeNodeNS', 'querySelector'
    ]
},

'Event': {
    'implicitJSContext': [ 'defaultPrevented', 'preventDefault' ],
},

'EventTarget': {
    # When we get rid of hasXPConnectImpls, we can get rid of the
    # couldBeDOMBinding stuff in WrapNewBindingObject.
    'hasXPConnectImpls': True,
    'concrete': False,
    'jsImplParent': 'mozilla::DOMEventTargetHelper'
},

'Exception': {
    'headerFile': 'mozilla/dom/DOMException.h',
    'binaryNames': {
        'message': 'messageMoz',
    },
},

'FileHandle': {
    'nativeType': 'mozilla::dom::file::FileHandle'
},

'FileList': {
    'nativeType': 'nsDOMFileList',
    'headerFile': 'nsDOMFile.h',
    'resultNotAddRefed': [ 'item' ]
},

'FileReader': {
    'nativeType': 'nsDOMFileReader',
    'implicitJSContext': [ 'readAsArrayBuffer' ],
},

'FileReaderSync': {
    'workers': True,
    'wrapperCache': False,
},

'FileRequest': {
    'nativeType': 'mozilla::dom::file::FileRequest',
},

'FormData': [
{
    'nativeType': 'nsFormData'
},
{
    'workers': True,
    'skipGen': True,
    'nativeType': 'JSObject'
}],

'GainNode': {
    'resultNotAddRefed': [ 'gain' ],
},

'Geolocation': {
    'headerFile': 'nsGeolocation.h'
},

'History': {
    'headerFile': 'nsHistory.h',
    'nativeType': 'nsHistory'
},

'HTMLAppletElement': {
    'nativeType': 'mozilla::dom::HTMLSharedObjectElement'
},

'HTMLBaseElement': {
    'nativeType': 'mozilla::dom::HTMLSharedElement'
},

'HTMLCollection': {
    'nativeType': 'nsIHTMLCollection',
    # nsContentList.h pulls in nsIHTMLCollection.h
    'headerFile': 'nsContentList.h',
    'resultNotAddRefed': [ 'item' ]
},

'HTMLDataListElement': {
    'resultNotAddRefed': [
        'options'
    ]
},

'HTMLDirectoryElement': {
    'nativeType': 'mozilla::dom::HTMLSharedElement'
},

'HTMLDListElement': {
    'nativeType' : 'mozilla::dom::HTMLSharedListElement'
},

'HTMLDocument': {
    'nativeType': 'nsHTMLDocument',
    'resultNotAddRefed': [ 'body', 'head', 'images', 'embeds', 'plugins',
                           'links', 'forms', 'scripts', 'anchors', 'applets' ],
    'implicitJSContext': [ 'open', 'write', 'writeln' ]
},

'HTMLElement': {
    'nativeType': 'nsGenericHTMLElement',
    'resultNotAddRefed': [
        'itemType', 'itemRef', 'itemProp', 'properties', 'contextMenu', 'style',
        'offsetParent'
    ]
},

'HTMLEmbedElement': {
    'nativeType': 'mozilla::dom::HTMLSharedObjectElement'
},

'HTMLHeadElement': {
    'nativeType': 'mozilla::dom::HTMLSharedElement'
},

'HTMLHtmlElement': {
    'nativeType': 'mozilla::dom::HTMLSharedElement'
},

'HTMLLabelElement': {
    'resultNotAddRefed': [
        'form', 'control'
    ],
},

'HTMLMediaElement': {
    'concrete': False
},

'HTMLOListElement': {
    'nativeType' : 'mozilla::dom::HTMLSharedListElement'
},

'HTMLOptionsCollection': {
    'resultNotAddRefed': [ 'item' ],
},

'HTMLParamElement': {
    'nativeType': 'mozilla::dom::HTMLSharedElement'
},

'HTMLPropertiesCollection': {
    'headerFile': 'HTMLPropertiesCollection.h',
    'resultNotAddRefed': [ 'item', 'namedItem', 'names' ]
},

'HTMLQuoteElement': {
    'nativeType': 'mozilla::dom::HTMLSharedElement'
},

'HTMLTableElement': {
    'resultNotAddRefed': [
        'caption', 'tHead', 'tFoot', 'tBodies', 'rows'
    ]
},

'HTMLTableRowElement': {
    'resultNotAddRefed': [
        'cells'
    ]
},

'HTMLTableSectionElement': {
    'resultNotAddRefed': [
        'rows'
    ]
},

'HTMLTemplateElement': {
    'resultNotAddRefed': [
        'content'
    ]
},

'HTMLTextAreaElement': {
    'resultNotAddRefed': [
        'form', 'controllers', 'editor'
    ],
    'binaryNames': {
        'textLength': 'getTextLength'
    }
},

'HTMLSelectElement': {
    'resultNotAddRefed': [
        'form',
        'item',
        'options',
        'IndexedGetter',
    ]
},

'HTMLStyleElement': {
    'resultNotAddRefed': [
        'sheet'
    ]
},

'HTMLUListElement': {
    'nativeType' : 'mozilla::dom::HTMLSharedListElement'
},

'IDBCursor': {
    'nativeType': 'mozilla::dom::indexedDB::IDBCursor',
    'implicitJSContext': [ 'delete' ],
    'binaryNames': {
        'direction': 'getDirection'
    }
},

'IDBCursorWithValue': {
    'nativeType': 'mozilla::dom::indexedDB::IDBCursor',
},

'IDBDatabase': {
    'nativeType': 'mozilla::dom::indexedDB::IDBDatabase',
},

'IDBFactory': {
    'nativeType': 'mozilla::dom::indexedDB::IDBFactory',
},

'IDBFileHandle': {
    'nativeType': 'mozilla::dom::indexedDB::IDBFileHandle',
},

'IDBIndex': {
    'nativeType': 'mozilla::dom::indexedDB::IDBIndex',
    'binaryNames': {
        'mozGetAll': 'getAll',
        'mozGetAllKeys': 'getAllKeys',
    }
},

'IDBKeyRange': {
    'nativeType': 'mozilla::dom::indexedDB::IDBKeyRange',
    'wrapperCache': False,
},

'IDBObjectStore': {
    'nativeType': 'mozilla::dom::indexedDB::IDBObjectStore',
    'implicitJSContext': [ 'createIndex' ],
    'binaryNames': {
        'mozGetAll': 'getAll'
    }
},

'IDBOpenDBRequest': {
    'nativeType': 'mozilla::dom::indexedDB::IDBOpenDBRequest',
    'headerFile': 'IDBRequest.h'
},

'IDBRequest': {
    'nativeType': 'mozilla::dom::indexedDB::IDBRequest',
},

'IDBTransaction': {
    'nativeType': 'mozilla::dom::indexedDB::IDBTransaction',
},

'IDBVersionChangeEvent': {
    'nativeType': 'mozilla::dom::indexedDB::IDBVersionChangeEvent',
    'headerFile': 'IDBEvents.h',
},

'IID': [
{
    'nativeType': 'nsIJSID',
    'headerFile': 'xpcjsid.h',
},
{
    'workers': True,
}],

'ImageData': {
    'wrapperCache': False,
},

'InputStream': [
{
    'nativeType': 'nsIInputStream',
    'notflattened': True
},
{
    'workers': True,
}],

'KeyEvent': {
    'concrete': False
},

'LocalMediaStream': {
    'headerFile': 'DOMMediaStream.h',
    'nativeType': 'mozilla::DOMLocalMediaStream'
},

'Location': {
    # NOTE: Before you turn on codegen for Location, make sure all the
    # Unforgeable stuff is dealt with.
    'nativeType': 'nsIDOMLocation',
    'skipGen': True,
    'register': False
},

'LockedFile': {
    'nativeType': 'mozilla::dom::file::LockedFile',
},

'MediaList': {
    'nativeType': 'nsMediaList',
    'headerFile': 'nsIMediaList.h',
},

'MediaSource': [{
    'resultNotAddRefed': [ 'sourceBuffers', 'activeSourceBuffers' ],
},
{
    'nativeType': 'JSObject',
    'workers': True,
    'skipGen': True
}],

'MediaStream': [{
    'headerFile': 'DOMMediaStream.h',
    'nativeType': 'mozilla::DOMMediaStream'
},
{
    'nativeType': 'JSObject',
    'workers': True,
    'skipGen': True
}],

'MediaStreamAudioDestinationNode': {
    'resultNotAddRefed': [ 'stream' ],
    'binaryNames': { 'stream': 'DOMStream' }
},

'MediaStreamList': {
    'headerFile': 'MediaStreamList.h',
    'resultNotAddRefed': [ '__indexedGetter' ],
    'binaryNames': { '__indexedGetter': 'IndexedGetter' }
},

'MediaStreamTrack': {
    'concrete': False
},

'MediaRecorder': {
    'headerFile': 'MediaRecorder.h',
    'resultNotAddRefed': [ 'stream' ]
},

'MessagePort': {
    'nativeType': 'mozilla::dom::MessagePortBase',
    'headerFile': 'mozilla/dom/MessagePort.h',
    'binaryNames': {
        'postMessage': 'postMessageMoz',
    },
},

'MimeType': {
    'headerFile' : 'nsMimeTypeArray.h',
    'nativeType': 'nsMimeType',
    'resultNotAddRefed': [ 'enabledPlugin' ]
},

'MimeTypeArray': {
    'nativeType': 'nsMimeTypeArray',
    'resultNotAddRefed': [ 'item', 'namedItem' ]
},

'MozCanvasPrintState': {
    'headerFile': 'mozilla/dom/HTMLCanvasElement.h',
    'nativeType': 'mozilla::dom::HTMLCanvasPrintState',
},

'MozChannel': [
{
    'nativeType': 'nsIChannel',
    'notflattened': True
},
{
    'workers': True,
}],

'MozCellBroadcast': {
    'nativeType': 'mozilla::dom::CellBroadcast',
},

'MozIcc': {
    'nativeType': 'mozilla::dom::Icc',
},

'MozIccManager': {
    'nativeType': 'mozilla::dom::IccManager',
},

'MozMobileConnectionArray': {
    'nativeType': 'mozilla::dom::MobileConnectionArray',
    'resultNotAddRefed': [ 'item' ]
},

'MozNamedAttrMap': {
    'nativeType': 'nsDOMAttributeMap',
},

'MozSpeakerManager': {
    'nativeType': 'mozilla::dom::SpeakerManager',
    'headerFile': 'SpeakerManager.h'
},

'MozPowerManager': {
    'nativeType': 'mozilla::dom::PowerManager',
},

'MozWakeLock': {
    'nativeType': 'mozilla::dom::WakeLock',
},

'MozTimeManager': {
    'nativeType': 'mozilla::dom::time::TimeManager',
},

'MozVoicemail': {
    'nativeType': 'mozilla::dom::Voicemail',
},

'MutationObserver': {
    'nativeType': 'nsDOMMutationObserver',
},

'MutationRecord': {
    'nativeType': 'nsDOMMutationRecord',
    'headerFile': 'nsDOMMutationObserver.h',
    'resultNotAddRefed': [ 'target', 'addedNodes', 'removedNodes',
                           'previousSibling', 'nextSibling' ]
},

'NetworkInformation': {
    'nativeType': 'mozilla::dom::network::Connection',
},

'Node': {
    'nativeType': 'nsINode',
    'concrete': False,
    'resultNotAddRefed': [ 'ownerDocument', 'parentNode', 'parentElement',
                           'childNodes', 'firstChild', 'lastChild',
                           'previousSibling', 'nextSibling', 'insertBefore',
                           'appendChild', 'replaceChild', 'removeChild',
                           'attributes' ],
    'binaryNames': {
        'baseURI': 'baseURIFromJS'
    }
},

'NodeIterator': {
    'wrapperCache': False,
    'resultNotAddRefed': [ 'root', 'referenceNode' ],
},

'NodeList': {
    'nativeType': 'nsINodeList',
    'resultNotAddRefed': [ 'item' ]
},

'OfflineAudioCompletionEvent': {
    'resultNotAddRefed': [ 'renderedBuffer' ],
},

'OfflineAudioContext': {
    'nativeType': 'mozilla::dom::AudioContext',
    'resultNotAddRefed': [ 'destination', 'listener' ],
},

'OfflineResourceList': {
    'nativeType': 'nsDOMOfflineResourceList',
},

'OscillatorNode': {
    'resultNotAddRefed': [ 'frequency', 'detune' ],
},

'PaintRequestList': {
    'headerFile': 'mozilla/dom/PaintRequest.h',
    'resultNotAddRefed': [ 'item' ]
},

'PannerNode': {
    'resultNotAddRefed': [ 'coneGain', 'distanceGain' ],
},

'Path2D': {
    'nativeType': 'mozilla::dom::CanvasPath',
    'headerFile': 'CanvasRenderingContext2D.h'
},

'PeerConnectionImpl': {
    'nativeType': 'sipcc::PeerConnectionImpl',
    'headerFile': 'PeerConnectionImpl.h',
    'wrapperCache': False
},

'Performance': {
    'nativeType': 'nsPerformance',
    'resultNotAddRefed': [ 'timing', 'navigation' ]
},

'PerformanceTiming': {
    'nativeType': 'nsPerformanceTiming',
    'headerFile': 'nsPerformance.h'
},

'PerformanceNavigation': {
    'nativeType': 'nsPerformanceNavigation',
    'headerFile': 'nsPerformance.h'
},

'Plugin': {
    'headerFile' : 'nsPluginArray.h',
    'nativeType': 'nsPluginElement',
    'resultNotAddRefed': [ 'item', 'namedItem' ]
},

'PluginArray': {
    'nativeType': 'nsPluginArray',
    'resultNotAddRefed': [ 'item', 'namedItem' ]
},

'Position': {
    'headerFile': 'nsGeoPosition.h'
},

'PositionError': {
    'headerFile': 'nsGeolocation.h'
},

'Promise': {
    'implicitJSContext': [ 'then', 'catch' ],
},

'PropertyNodeList': {
    'headerFile': 'HTMLPropertiesCollection.h',
    'resultNotAddRefed': [ 'item' ]
},

'Range': {
    'nativeType': 'nsRange',
    'resultNotAddRefed': [ 'startContainer', 'endContainer', 'commonAncestorContainer' ],
    'binaryNames': {
        '__stringifier': 'ToString'
    }
},

'Rect': {
    'nativeType': 'nsDOMCSSRect',
    'resultNotAddRefed': [ 'top', 'right', 'bottom', 'left' ]
},

'RGBColor': {
    'nativeType': 'nsDOMCSSRGBColor',
    'resultNotAddRefed': [ 'alpha', 'blue', 'green', 'red' ]
},

'Screen': {
    'nativeType': 'nsScreen',
},

'Selection': {
    'resultNotAddRefed': [ 'anchorNode', 'focusNode', 'getRangeAt' ],
},

'ShadowRoot': {
    'resultNotAddRefed': [
        'styleSheets'
    ]
},

'HTMLShadowElement': {
    'resultNotAddRefed': [
        'getOldShadowRoot'
    ]
},

'SharedWorker': {
    'nativeType': 'mozilla::dom::workers::SharedWorker',
    'headerFile': 'mozilla/dom/workers/bindings/SharedWorker.h',
    'implicitJSContext': [ 'constructor' ],
},

'SharedWorkerGlobalScope': {
    'headerFile': 'mozilla/dom/WorkerScope.h',
    'workers': True,
},

'SourceBufferList': {
    'resultNotAddRefed': [ '__indexedGetter' ],
},

'StyleSheet': {
    'nativeType': 'nsCSSStyleSheet',
},

'SVGAnimatedLengthList': {
    'nativeType': 'mozilla::DOMSVGAnimatedLengthList',
    'headerFile': 'DOMSVGAnimatedLengthList.h',
},

'SVGAnimatedNumberList': {
    'nativeType': 'mozilla::DOMSVGAnimatedNumberList',
    'headerFile': 'DOMSVGAnimatedNumberList.h'
},

'SVGAnimatedPreserveAspectRatio': {
    'nativeType': 'mozilla::dom::DOMSVGAnimatedPreserveAspectRatio',
    'headerFile': 'SVGAnimatedPreserveAspectRatio.h'
},

'SVGAnimationElement': {
    'resultNotAddRefed': ['targetElement'],
    'concrete': False
},

'SVGComponentTransferFunctionElement': {
    'concrete': False,
},

'SVGElement': {
    'nativeType': 'nsSVGElement',
    'resultNotAddRefed': ['ownerSVGElement', 'viewportElement', 'style']
},

'SVGFEFuncAElement': {
    'headerFile': 'mozilla/dom/SVGComponentTransferFunctionElement.h',
},

'SVGFEFuncBElement': {
    'headerFile': 'mozilla/dom/SVGComponentTransferFunctionElement.h',
},

'SVGFEFuncGElement': {
    'headerFile': 'mozilla/dom/SVGComponentTransferFunctionElement.h',
},

'SVGFEFuncRElement': {
    'headerFile': 'mozilla/dom/SVGComponentTransferFunctionElement.h',
},

'SVGGraphicsElement': {
    'concrete': False,
    'resultNotAddRefed': ['nearestViewportElement', 'farthestViewportElement']
},

'SVGGradientElement': {
    'concrete': False,
},

'SVGLength': {
    'nativeType': 'mozilla::DOMSVGLength',
    'headerFile': 'DOMSVGLength.h'
},

'SVGLengthList': {
    'nativeType': 'mozilla::DOMSVGLengthList',
    'headerFile': 'DOMSVGLengthList.h'
},

'SVGLinearGradientElement': {
    'headerFile': 'mozilla/dom/SVGGradientElement.h',
},

'SVGNumberList': {
    'nativeType': 'mozilla::DOMSVGNumberList',
    'headerFile': 'DOMSVGNumberList.h'
},

'SVGPathSeg': {
    'nativeType': 'mozilla::DOMSVGPathSeg',
    'headerFile': 'DOMSVGPathSeg.h',
    'concrete': False,
},

'SVGPathSegClosePath': {
    'nativeType': 'mozilla::DOMSVGPathSegClosePath',
    'headerFile': 'DOMSVGPathSeg.h'
},

'SVGPathSegMovetoAbs': {
    'nativeType': 'mozilla::DOMSVGPathSegMovetoAbs',
    'headerFile': 'DOMSVGPathSeg.h'
},

'SVGPathSegMovetoRel': {
    'nativeType': 'mozilla::DOMSVGPathSegMovetoRel',
    'headerFile': 'DOMSVGPathSeg.h'
},

'SVGPathSegLinetoAbs': {
    'nativeType': 'mozilla::DOMSVGPathSegLinetoAbs',
    'headerFile': 'DOMSVGPathSeg.h'
},

'SVGPathSegLinetoRel': {
    'nativeType': 'mozilla::DOMSVGPathSegLinetoRel',
    'headerFile': 'DOMSVGPathSeg.h'
},

'SVGPathSegCurvetoCubicAbs': {
    'nativeType': 'mozilla::DOMSVGPathSegCurvetoCubicAbs',
    'headerFile': 'DOMSVGPathSeg.h'
},

'SVGPathSegCurvetoCubicRel': {
    'nativeType': 'mozilla::DOMSVGPathSegCurvetoCubicRel',
    'headerFile': 'DOMSVGPathSeg.h'
},

'SVGPathSegCurvetoQuadraticAbs': {
    'nativeType': 'mozilla::DOMSVGPathSegCurvetoQuadraticAbs',
    'headerFile': 'DOMSVGPathSeg.h'
},

'SVGPathSegCurvetoQuadraticRel': {
    'nativeType': 'mozilla::DOMSVGPathSegCurvetoQuadraticRel',
    'headerFile': 'DOMSVGPathSeg.h'
},

'SVGPathSegArcAbs': {
    'nativeType': 'mozilla::DOMSVGPathSegArcAbs',
    'headerFile': 'DOMSVGPathSeg.h'
},

'SVGPathSegArcRel': {
    'nativeType': 'mozilla::DOMSVGPathSegArcRel',
    'headerFile': 'DOMSVGPathSeg.h'
},

'SVGPathSegLinetoHorizontalAbs': {
    'nativeType': 'mozilla::DOMSVGPathSegLinetoHorizontalAbs',
    'headerFile': 'DOMSVGPathSeg.h'
},

'SVGPathSegLinetoHorizontalRel': {
    'nativeType': 'mozilla::DOMSVGPathSegLinetoHorizontalRel',
    'headerFile': 'DOMSVGPathSeg.h'
},

'SVGPathSegLinetoVerticalAbs': {
    'nativeType': 'mozilla::DOMSVGPathSegLinetoVerticalAbs',
    'headerFile': 'DOMSVGPathSeg.h'
},

'SVGPathSegLinetoVerticalRel': {
    'nativeType': 'mozilla::DOMSVGPathSegLinetoVerticalRel',
    'headerFile': 'DOMSVGPathSeg.h'
},

'SVGPathSegCurvetoCubicSmoothAbs': {
    'nativeType': 'mozilla::DOMSVGPathSegCurvetoCubicSmoothAbs',
    'headerFile': 'DOMSVGPathSeg.h'
},

'SVGPathSegCurvetoCubicSmoothRel': {
    'nativeType': 'mozilla::DOMSVGPathSegCurvetoCubicSmoothRel',
    'headerFile': 'DOMSVGPathSeg.h'
},

'SVGPathSegCurvetoQuadraticSmoothAbs': {
    'nativeType': 'mozilla::DOMSVGPathSegCurvetoQuadraticSmoothAbs',
    'headerFile': 'DOMSVGPathSeg.h'
},

'SVGPathSegCurvetoQuadraticSmoothRel': {
    'nativeType': 'mozilla::DOMSVGPathSegCurvetoQuadraticSmoothRel',
    'headerFile': 'DOMSVGPathSeg.h'
},

'SVGPathSegList': {
    'nativeType': 'mozilla::DOMSVGPathSegList',
    'headerFile': 'DOMSVGPathSegList.h'
},

'SVGPoint': {
    'nativeType': 'mozilla::nsISVGPoint',
    'headerFile': 'nsISVGPoint.h'
},

'SVGPointList': {
    'nativeType': 'mozilla::DOMSVGPointList',
    'headerFile': 'DOMSVGPointList.h'
},

'SVGPreserveAspectRatio': {
    'nativeType': 'mozilla::dom::DOMSVGPreserveAspectRatio',
    'headerFile': 'SVGPreserveAspectRatio.h'
},

'SVGRadialGradientElement': {
    'headerFile': 'mozilla/dom/SVGGradientElement.h',
},

'SVGRect': {
    'nativeType': 'mozilla::dom::SVGIRect'
},

'SVGTextContentElement': {
    'concrete': False
},

'SVGTextPositioningElement': {
    'concrete': False
},

'SVGTransform': {
    'resultNotAddRefed': [ 'matrix' ],
    'binaryNames': {
        "matrix": "GetMatrix"
    }
},

'SVGTransformList': {
    'nativeType': 'mozilla::DOMSVGTransformList',
    'headerFile': 'DOMSVGTransformList.h'
},

'SVGStringList': {
    'nativeType': 'mozilla::DOMSVGStringList',
    'headerFile': 'DOMSVGStringList.h',
},

'SVGSVGElement': {
    'resultNotAddRefed': [ 'getElementById' ]
},

'SVGUnitTypes' : {
    'concrete': False,
},

'SVGZoomAndPan' : {
    'concrete': False,
},

'Text': {
    # Total hack to allow binding code to realize that nsTextNode can
    # in fact be cast to Text.
    'headerFile': 'nsTextNode.h',
},

'TextDecoder': {
    'nativeOwnership': 'owned',
},

'TextEncoder': {
    'nativeOwnership': 'owned',
},

'TextMetrics': {
    'nativeOwnership': 'owned',
},

'TimeRanges': {
    'wrapperCache': False
},

'TouchList': {
    'headerFile': 'mozilla/dom/TouchEvent.h',
},

'TreeColumns': {
    'nativeType': 'nsTreeColumns',
},

'TreeWalker': {
    'wrapperCache': False,
    'resultNotAddRefed': [ 'root', 'currentNode' ],
},

'UndoManager': {
    'implicitJSContext' : [ 'undo', 'redo', 'transact' ],
},

'URL' : [{
    'wrapperCache': False,
},
{
    'workers': True,
    'wrapperCache': False,
}],

'VTTCue': {
    'nativeType': 'mozilla::dom::TextTrackCue'
},

'VTTRegion': {
  'nativeType': 'mozilla::dom::TextTrackRegion',
},

'WebGLActiveInfo': {
    'nativeType': 'mozilla::WebGLActiveInfo',
    'headerFile': 'WebGLActiveInfo.h',
    'wrapperCache': False
},

'WebGLBuffer': {
    'nativeType': 'mozilla::WebGLBuffer',
    'headerFile': 'WebGLBuffer.h'
},

'WebGLExtensionCompressedTextureATC': {
    'nativeType': 'mozilla::WebGLExtensionCompressedTextureATC',
    'headerFile': 'WebGLExtensions.h'
},

'WebGLExtensionCompressedTextureETC1': {
    'nativeType': 'mozilla::WebGLExtensionCompressedTextureETC1',
    'headerFile': 'WebGLExtensions.h'
},

'WebGLExtensionCompressedTexturePVRTC': {
    'nativeType': 'mozilla::WebGLExtensionCompressedTexturePVRTC',
    'headerFile': 'WebGLExtensions.h'
},

'WebGLExtensionCompressedTextureS3TC': {
    'nativeType': 'mozilla::WebGLExtensionCompressedTextureS3TC',
    'headerFile': 'WebGLExtensions.h'
},

'WebGLExtensionDepthTexture': {
    'nativeType': 'mozilla::WebGLExtensionDepthTexture',
    'headerFile': 'WebGLExtensions.h'
},

'WebGLExtensionDebugRendererInfo': {
    'nativeType': 'mozilla::WebGLExtensionDebugRendererInfo',
    'headerFile': 'WebGLExtensions.h'
},

'WebGLExtensionDebugShaders': {
    'nativeType': 'mozilla::WebGLExtensionDebugShaders',
    'headerFile': 'WebGLExtensions.h'
},

'WebGLExtensionElementIndexUint': {
    'nativeType': 'mozilla::WebGLExtensionElementIndexUint',
    'headerFile': 'WebGLExtensions.h'
},

'WebGLExtensionFragDepth': {
    'nativeType': 'mozilla::WebGLExtensionFragDepth',
    'headerFile': 'WebGLExtensions.h'
},

'WebGLExtensionLoseContext': {
    'nativeType': 'mozilla::WebGLExtensionLoseContext',
    'headerFile': 'WebGLExtensions.h'
},

'WebGLExtensionSRGB': {
    'nativeType': 'mozilla::WebGLExtensionSRGB',
    'headerFile': 'WebGLExtensions.h'
},

'WebGLExtensionStandardDerivatives': {
    'nativeType': 'mozilla::WebGLExtensionStandardDerivatives',
    'headerFile': 'WebGLExtensions.h'
},

'WebGLExtensionTextureFilterAnisotropic': {
    'nativeType': 'mozilla::WebGLExtensionTextureFilterAnisotropic',
    'headerFile': 'WebGLExtensions.h'
},

'WebGLExtensionTextureFloat': {
    'nativeType': 'mozilla::WebGLExtensionTextureFloat',
    'headerFile': 'WebGLExtensions.h'
},

'WebGLExtensionTextureFloatLinear': {
    'nativeType': 'mozilla::WebGLExtensionTextureFloatLinear',
    'headerFile': 'WebGLExtensions.h'
},

'WebGLExtensionTextureHalfFloat': {
   'nativeType': 'mozilla::WebGLExtensionTextureHalfFloat',
   'headerFile': 'WebGLExtensions.h'
},

'WebGLExtensionTextureHalfFloatLinear': {
   'nativeType': 'mozilla::WebGLExtensionTextureHalfFloatLinear',
   'headerFile': 'WebGLExtensions.h'
},

'WebGLExtensionColorBufferFloat': {
   'nativeType': 'mozilla::WebGLExtensionColorBufferFloat',
   'headerFile': 'WebGLExtensions.h'
},

'WebGLExtensionColorBufferHalfFloat': {
   'nativeType': 'mozilla::WebGLExtensionColorBufferHalfFloat',
   'headerFile': 'WebGLExtensions.h'
},

'WebGLExtensionDrawBuffers': {
    'nativeType': 'mozilla::WebGLExtensionDrawBuffers',
    'headerFile': 'WebGLExtensions.h'
},

'WebGLExtensionVertexArray': {
    'nativeType': 'mozilla::WebGLExtensionVertexArray',
    'headerFile': 'WebGLExtensions.h'
},

'WebGLExtensionInstancedArrays': {
    'nativeType': 'mozilla::WebGLExtensionInstancedArrays',
    'headerFile': 'WebGLExtensions.h'
},

'WebGLFramebuffer': {
    'nativeType': 'mozilla::WebGLFramebuffer',
    'headerFile': 'WebGLFramebuffer.h'
},

'WebGLProgram': {
    'nativeType': 'mozilla::WebGLProgram',
    'headerFile': 'WebGLProgram.h'
},

'WebGLQuery': {
    'nativeType': 'mozilla::WebGLQuery',
    'headerFile': 'WebGLQuery.h'
},

'WebGLRenderbuffer': {
    'nativeType': 'mozilla::WebGLRenderbuffer',
    'headerFile': 'WebGLRenderbuffer.h'
},

'WebGLRenderingContext': {
    'nativeType': 'mozilla::WebGLContext',
    'headerFile': 'WebGLContext.h',
    'resultNotAddRefed': [ 'canvas', 'getContextAttributes', 'getExtension',
                           'getAttachedShaders' ],
    'implicitJSContext': [ 'getSupportedExtensions' ],
},

'WebGL2RenderingContext': {
    'nativeType': 'mozilla::WebGLContext',
    'headerFile': 'WebGLContext.h',
    'resultNotAddRefed': [ 'canvas', 'getContextAttributes', 'getExtension',
                           'getAttachedShaders' ],
    'implicitJSContext': [ 'getSupportedExtensions' ],
},

'WebGLShader': {
    'nativeType': 'mozilla::WebGLShader',
    'headerFile': 'WebGLShader.h'
},

'WebGLShaderPrecisionFormat': {
    'nativeType': 'mozilla::WebGLShaderPrecisionFormat',
    'headerFile': 'WebGLShaderPrecisionFormat.h',
    'wrapperCache': False
},

'WebGLTexture': {
    'nativeType': 'mozilla::WebGLTexture',
    'headerFile': 'WebGLTexture.h'
},

'WebGLUniformLocation': {
    'nativeType': 'mozilla::WebGLUniformLocation',
    'headerFile': 'WebGLUniformLocation.h',
    'wrapperCache': False
},

'WebGLVertexArray': {
    'nativeType': 'mozilla::WebGLVertexArray',
    'headerFile': 'WebGLVertexArray.h'
},

'WebrtcGlobalInformation': {
    'nativeType': 'mozilla::dom::WebrtcGlobalInformation',
    'headerFile': 'WebrtcGlobalInformation.h',
    'wrapperCache': False,
    'concrete': False,
},

'WebSocket': {
    'headerFile': 'WebSocket.h',
},

'Window': {
    'nativeType': 'nsGlobalWindow',
    # When turning on Window, remember to drop the "'register': False"
    # from ChromeWindow.
    'hasXPConnectImpls': True,
    'register': False,
    'binaryNames': {
        'postMessage': 'postMessageMoz',
    },
},

'WindowProxy': [
{
    'nativeType': 'nsIDOMWindow',
    'concrete': False
},
{
    # We need a worker descriptor for WindowProxy because EventTarget exists in
    # workers.  But it's an external interface, so it'll just map to JSObject*.
    'workers': True
}],

'Worker': {
    'headerFile': 'mozilla/dom/WorkerPrivate.h',
    'nativeType': 'mozilla::dom::workers::WorkerPrivate',
    'implicitJSContext': [
        'terminate',
    ],
},

'WorkerGlobalScope': {
    'headerFile': 'mozilla/dom/WorkerScope.h',
    'workers': True,
    'concrete': False,
    'implicitJSContext': [
        'close', 'importScripts',
    ],
    'binaryNames': { 'console': 'getConsole', },
},

'WorkerLocation': {
    'headerFile': 'mozilla/dom/workers/bindings/Location.h',
    'workers': True,
},

'WorkerNavigator': {
    'headerFile': 'mozilla/dom/workers/bindings/Navigator.h',
    'workers': True,
},

'XMLHttpRequest': [
{
    'nativeType': 'nsXMLHttpRequest',
    'implicitJSContext': [ 'constructor', 'send'],
    'resultNotAddRefed': [ 'upload', 'responseXML' ]
},
{
    'workers': True,
    # XXXkhuey responseXML returns Document? which boils down to a JSObject*
    # on a worker, and nsRefPtr<JSObject> fails in the expected way. channel is
    # similar.  This is ugly but it's all going away soon anyways.
    'resultNotAddRefed': [
        'responseXML', 'channel'
    ]
}],

'XMLHttpRequestEventTarget': {
    'nativeType': 'nsXHREventTarget',
    'headerFile': 'nsXMLHttpRequest.h',
    'concrete': False
},

'XMLHttpRequestUpload': [
{
    'nativeType': 'nsXMLHttpRequestUpload',
    'headerFile': 'nsXMLHttpRequest.h'
},
{
    'workers': True,
}],

'XMLSerializer': {
    'nativeType': 'nsDOMSerializer',
},

'XMLStylesheetProcessingInstruction': {
    'resultNotAddRefed': [ 'sheet' ]
},

'XPathEvaluator': {
    'wrapperCache': False
},

'XULDocument': {
    'headerFile': 'XULDocument.h'
},

'XULElement': {
    'nativeType': 'nsXULElement',
    'resultNotAddRefed': [ 'controllers', 'style' ]
},

####################################
# Test Interfaces of various sorts #
####################################

'TestInterface' : {
        # Keep this in sync with TestExampleInterface
        'headerFile': 'TestBindingHeader.h',
        'register': False,
        'resultNotAddRefed': [ 'receiveWeakSelf', 'receiveWeakNullableSelf',
                               'receiveWeakOther', 'receiveWeakNullableOther',
                               'receiveWeakExternal', 'receiveWeakNullableExternal',
                               'ReceiveWeakCallbackInterface',
                               'ReceiveWeakNullableCallbackInterface',
                               'receiveWeakCastableObjectSequence',
                               'receiveWeakNullableCastableObjectSequence',
                               'receiveWeakCastableObjectNullableSequence',
                               'receiveWeakNullableCastableObjectNullableSequence' ],
        'binaryNames': { 'methodRenamedFrom': 'methodRenamedTo',
                         'attributeGetterRenamedFrom': 'attributeGetterRenamedTo',
                         'attributeRenamedFrom': 'attributeRenamedTo' }
        },

'TestParentInterface' : {
        'headerFile': 'TestBindingHeader.h',
        'register': False,
        },

'TestChildInterface' : {
        'headerFile': 'TestBindingHeader.h',
        'register': False,
        },

'TestCImplementedInterface' : {
        'headerFile': 'TestCImplementedInterface.h',
        'register': False,
        },

'TestCImplementedInterface2' : {
        'headerFile': 'TestCImplementedInterface.h',
        'register': False,
        },

'TestJSImplInterface' : {
        # Keep this in sync with TestExampleInterface
        'headerFile': 'TestJSImplGenBinding.h',
        'register': False,
        'resultNotAddRefed': [ 'receiveWeakSelf', 'receiveWeakNullableSelf',
                               'receiveWeakOther', 'receiveWeakNullableOther',
                               'receiveWeakExternal', 'receiveWeakNullableExternal',
                               'ReceiveWeakCallbackInterface',
                               'ReceiveWeakNullableCallbackInterface',
                               'receiveWeakCastableObjectSequence',
                               'receiveWeakNullableCastableObjectSequence',
                               'receiveWeakCastableObjectNullableSequence',
                               'receiveWeakNullableCastableObjectNullableSequence' ],
        'binaryNames': { 'methodRenamedFrom': 'methodRenamedTo',
                         'attributeGetterRenamedFrom': 'attributeGetterRenamedTo',
                         'attributeRenamedFrom': 'attributeRenamedTo' }
        },

'TestJSImplInterface2' : {
        'headerFile': 'TestJSImplGenBinding.h',
        'register': False
        },

'TestJSImplInterface3' : {
        'headerFile': 'TestJSImplGenBinding.h',
        'register': False
        },

'TestJSImplInterface4' : {
        'headerFile': 'TestJSImplGenBinding.h',
        'register': False
        },

'TestJSImplInterface5' : {
        'headerFile': 'TestJSImplGenBinding.h',
        'register': False
        },

'TestJSImplInterface6' : {
        'headerFile': 'TestJSImplGenBinding.h',
        'register': False
        },

'TestNavigator' : {
        'headerFile': 'TestJSImplGenBinding.h',
        'register' : False
        },

'TestNavigatorWithConstructor' : {
        'headerFile': 'TestJSImplGenBinding.h',
        'register' : False
        },

'TestExternalInterface' : {
        'nativeType': 'mozilla::dom::TestExternalInterface',
        'headerFile': 'TestBindingHeader.h',
        'register': False
        },

'TestNonWrapperCacheInterface' : {
        'headerFile': 'TestBindingHeader.h',
        'register': False,
        'wrapperCache': False
        },

'IndirectlyImplementedInterface': {
        'headerFile': 'TestBindingHeader.h',
        'register': False,
        'castable': False,
        'concrete': False
        },

'OnlyForUseInConstructor' : {
        'headerFile': 'TestBindingHeader.h',
        'register': False
        },

'ImplementedInterface' : {
        'headerFile': 'TestBindingHeader.h',
        'concrete': False,
        'register': False,
        },

'ImplementedInterfaceParent' : {
        'headerFile': 'TestBindingHeader.h',
        'concrete': False,
        'register': False
        },

'DiamondImplements' : {
        'headerFile': 'TestBindingHeader.h',
        'concrete': False,
        'register': False
        },

'DiamondBranch1A' : {
        'headerFile': 'TestBindingHeader.h',
        'concrete': False,
        'register': False
        },

'DiamondBranch1B' : {
        'headerFile': 'TestBindingHeader.h',
        'concrete': False,
        'register': False
        },

'DiamondBranch2A' : {
        'headerFile': 'TestBindingHeader.h',
        'concrete': False,
        'register': False
        },

'DiamondBranch2B' : {
        'headerFile': 'TestBindingHeader.h',
        'concrete': False,
        'register': False
        },

'TestIndexedGetterInterface' : {
        'headerFile': 'TestBindingHeader.h',
        'register': False
        },

'TestNamedGetterInterface' : {
        'headerFile': 'TestBindingHeader.h',
        'register': False
        },

'TestIndexedGetterAndSetterAndNamedGetterInterface' : {
        'headerFile': 'TestBindingHeader.h',
        'register': False
        },

'TestIndexedAndNamedGetterInterface' : {
        'headerFile': 'TestBindingHeader.h',
        'register': False
        },

'TestIndexedSetterInterface' : {
        'headerFile': 'TestBindingHeader.h',
        'register': False
        },

'TestNamedSetterInterface' : {
        'headerFile': 'TestBindingHeader.h',
        'register': False
        },

'TestIndexedAndNamedSetterInterface' : {
        'headerFile': 'TestBindingHeader.h',
        'register': False
        },

'TestIndexedAndNamedGetterAndSetterInterface' : {
        'headerFile': 'TestBindingHeader.h',
        'register': False,
        },

'TestRenamedInterface' : {
        'headerFile': 'TestBindingHeader.h',
        'register': False,
        'nativeType': 'nsRenamedInterface'
        },

'TestIndexedDeleterInterface' : {
        'headerFile': 'TestBindingHeader.h',
        'register': False
        },

'TestIndexedDeleterWithRetvalInterface' : {
        'headerFile': 'TestBindingHeader.h',
        'register': False
        },

'TestNamedDeleterInterface' : {
        'headerFile': 'TestBindingHeader.h',
        'register': False
        },

'TestNamedDeleterWithRetvalInterface' : {
        'headerFile': 'TestBindingHeader.h',
        'register': False
        },

'TestIndexedAndNamedDeleterInterface' : {
        'headerFile': 'TestBindingHeader.h',
        'register': False
        },

'TestCppKeywordNamedMethodsInterface' : {
        'headerFile': 'TestBindingHeader.h',
        'register': False
        },

'TestExampleInterface' : {
        # Keep this in sync with TestInterface
        'headerFile': 'TestExampleInterface-example.h',
        'register': False,
        'resultNotAddRefed': [ 'receiveWeakSelf', 'receiveWeakNullableSelf',
                               'receiveWeakOther', 'receiveWeakNullableOther',
                               'receiveWeakExternal', 'receiveWeakNullableExternal',
                               'ReceiveWeakCallbackInterface',
                               'ReceiveWeakNullableCallbackInterface',
                               'receiveWeakCastableObjectSequence',
                               'receiveWeakNullableCastableObjectSequence',
                               'receiveWeakCastableObjectNullableSequence',
                               'receiveWeakNullableCastableObjectNullableSequence' ],
        'binaryNames': { 'methodRenamedFrom': 'methodRenamedTo',
                         'attributeGetterRenamedFrom': 'attributeGetterRenamedTo',
                         'attributeRenamedFrom': 'attributeRenamedTo' }
        },

'TestExampleProxyInterface' : {
        'headerFile': 'TestExampleProxyInterface-example.h',
        'register': False
        }
}

# These are temporary, until they've been converted to use new DOM bindings
def addExternalIface(iface, nativeType=None, headerFile=None,
                     notflattened=False):
    if iface in DOMInterfaces:
        raise Exception('Interface declared both as WebIDL and External interface')
    domInterface = {
        'concrete': False
    }
    if not nativeType is None:
        domInterface['nativeType'] = nativeType
    if not headerFile is None:
        domInterface['headerFile'] = headerFile
    domInterface['notflattened'] = notflattened
    DOMInterfaces[iface] = domInterface

addExternalIface('ApplicationCache', nativeType='nsIDOMOfflineResourceList')
addExternalIface('Counter')
addExternalIface('CSSRule')
addExternalIface('mozIDOMApplication', nativeType='mozIDOMApplication', headerFile='nsIDOMApplicationRegistry.h')
addExternalIface('CSSRuleList')
addExternalIface('RTCDataChannel', nativeType='nsIDOMDataChannel')
addExternalIface('File')
addExternalIface('HitRegionOptions', nativeType='nsISupports')
addExternalIface('imgINotificationObserver', nativeType='imgINotificationObserver')
addExternalIface('imgIRequest', nativeType='imgIRequest', notflattened=True)
addExternalIface('MenuBuilder', nativeType='nsIMenuBuilder', notflattened=True)
addExternalIface('MozBoxObject', nativeType='nsIBoxObject')
addExternalIface('MozControllers', nativeType='nsIControllers')
addExternalIface('MozFrameLoader', nativeType='nsIFrameLoader', notflattened=True)
addExternalIface('MozFrameRequestCallback', nativeType='nsIFrameRequestCallback',
                 notflattened=True)
addExternalIface('MozIccInfo', headerFile='nsIDOMIccInfo.h')
addExternalIface('MozMobileConnection', headerFile='nsIDOMMobileConnection.h')
addExternalIface('MozMobileMessageManager', headerFile='nsIDOMMobileMessageManager.h')
addExternalIface('MozObserver', nativeType='nsIObserver', notflattened=True)
addExternalIface('MozRDFCompositeDataSource', nativeType='nsIRDFCompositeDataSource',
                 notflattened=True)
addExternalIface('MozRDFResource', nativeType='nsIRDFResource', notflattened=True)
addExternalIface('MozTreeBoxObject', nativeType='nsITreeBoxObject',
                 notflattened=True)
addExternalIface('MozTreeColumn', nativeType='nsITreeColumn',
                 headerFile='nsITreeColumns.h')
addExternalIface('MozVoicemailStatus')
addExternalIface('MozWakeLockListener', headerFile='nsIDOMWakeLockListener.h')
addExternalIface('MozXULTemplateBuilder', nativeType='nsIXULTemplateBuilder')
addExternalIface('nsIBrowserDOMWindow', nativeType='nsIBrowserDOMWindow',
                 notflattened=True)
addExternalIface('nsIControllers', nativeType='nsIControllers')
addExternalIface('nsIDOMCrypto', nativeType='nsIDOMCrypto',
                 headerFile='Crypto.h')
addExternalIface('nsIInputStreamCallback', nativeType='nsIInputStreamCallback',
                 headerFile='nsIAsyncInputStream.h')
addExternalIface('nsIMessageBroadcaster', nativeType='nsIMessageBroadcaster',
                 headerFile='nsIMessageManager.h', notflattened=True)
addExternalIface('nsISelectionListener', nativeType='nsISelectionListener')
addExternalIface('nsIStreamListener', nativeType='nsIStreamListener', notflattened=True)
addExternalIface('nsISupports', nativeType='nsISupports')
addExternalIface('nsIDocShell', nativeType='nsIDocShell', notflattened=True)
addExternalIface('nsIEditor', nativeType='nsIEditor', notflattened=True)
addExternalIface('nsIVariant', nativeType='nsIVariant', notflattened=True)
addExternalIface('OutputStream', nativeType='nsIOutputStream',
                 notflattened=True)
addExternalIface('Principal', nativeType='nsIPrincipal',
                 headerFile='nsIPrincipal.h', notflattened=True)
addExternalIface('StackFrame', nativeType='nsIStackFrame',
                 headerFile='nsIException.h', notflattened=True)
addExternalIface('SVGNumber')
addExternalIface('URI', nativeType='nsIURI', headerFile='nsIURI.h',
                 notflattened=True)
addExternalIface('UserDataHandler')
addExternalIface('XPathResult', nativeType='nsISupports')
addExternalIface('XPathExpression')
addExternalIface('XPathNSResolver')
addExternalIface('XULCommandDispatcher')
