gecko/dom/bindings/Bindings.conf
Brian Birtles b1759d304e Bug 1040543 part 1 - Move/Rename ElementAnimations to dom::AnimationPlayer; r=bz
This patch renames mozilla::ElementAnimations to mozilla::dom::AnimationPlayer
and moves the code from layout/style/AnimationCommon.cpp to
dom/animation/AnimationPlayer.cpp.

It also moves various helper classes needed by AnimationPlayer to
AnimationPlayer.cpp and moves them from the mozilla::css namespace to the
mozilla namespace.

Beyond that, there are no functional changes contained in this patch.

The renaming of various members and variables that used to refer to
ElementAnimation objects but now refer to AnimationPlayer objects--to give them
a more appropriate name--is performed in a subsequent patch.

--HG--
rename : layout/style/AnimationCommon.cpp => dom/animation/AnimationPlayer.cpp
rename : layout/style/AnimationCommon.h => dom/animation/AnimationPlayer.h
2014-08-10 17:06:44 +10:00

2040 lines
52 KiB
Plaintext

# 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::archivereader::ArchiveReader',
},
'ArchiveRequest': {
'nativeType': 'mozilla::dom::archivereader::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',
},
'BluetoothClassOfDevice': {
'nativeType': 'mozilla::dom::bluetooth::BluetoothClassOfDevice',
},
'BluetoothDevice': {
'nativeType': 'mozilla::dom::bluetooth::BluetoothDevice',
},
'BluetoothDiscoveryHandle': {
'nativeType': 'mozilla::dom::bluetooth::BluetoothDiscoveryHandle',
},
'BluetoothManager': {
'nativeType': 'mozilla::dom::bluetooth::BluetoothManager',
},
'BluetoothPairingHandle': {
'nativeType': 'mozilla::dom::bluetooth::BluetoothPairingHandle',
},
'BluetoothPairingListener': {
'nativeType':
'mozilla::dom::bluetooth::BluetoothPairingListener',
},
'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'
},
'CanvasRenderingContext2D': {
'implicitJSContext': [
'createImageData', 'getImageData'
],
'resultNotAddRefed': [ 'canvas', 'measureText' ],
'binaryNames': {
'mozImageSmoothingEnabled': 'imageSmoothingEnabled',
'mozFillRule': 'fillRule'
}
},
'CaretPosition' : {
'nativeType': 'nsDOMCaretPosition',
},
'CharacterData': {
'nativeType': 'nsGenericDOMDataNode',
'concrete': False
},
'ChromeWindow': {
'concrete': 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': 'mozilla::CSSStyleSheet',
'binaryNames': { 'ownerRule': 'DOMOwnerRule' },
},
'CSSValue': {
'concrete': False
},
'CSSValueList': {
'nativeType': 'nsDOMCSSValueList'
},
'DataChannel': {
'nativeType': 'nsDOMDataChannel',
},
'DataStore': [{
'workers': False
}, {
'workers': True,
'nativeType': 'mozilla::dom::workers::WorkerDataStore',
'implicitJSContext': ['name', 'owner', 'readOnly', 'get', 'remove',
'clear', 'revisionId', 'getLength', 'sync']
}],
'DataStoreCursor': [{
'workers': False,
'wrapperCache': False
}, {
'workers': True,
'nativeType': 'mozilla::dom::workers::WorkerDataStoreCursor',
'wrapperCache': False,
'implicitJSContext': ['store', 'next', 'close']
}],
'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'
}
},
# Note: we still need the worker descriptor here because
# XMLHttpRequest.send() uses it.
{
'nativeType': 'JSObject',
'workers': True,
'skipGen': True
}],
'DocumentFragment': {
'resultNotAddRefed': [ 'querySelector' ]
},
'DOMException': {
'binaryNames': {
'message': 'messageMoz',
},
},
'DOMMatrixReadOnly': {
'headerFile': 'mozilla/dom/DOMMatrix.h',
'concrete': False,
},
'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',
},
},
'FileList': {
'nativeType': 'nsDOMFileList',
'headerFile': 'nsDOMFile.h',
'resultNotAddRefed': [ 'item' ]
},
'FileReader': {
'nativeType': 'nsDOMFileReader',
'implicitJSContext': [ 'readAsArrayBuffer' ],
},
'FileReaderSync': {
'workers': True,
'wrapperCache': False,
},
'FormData': [
{
'nativeType': 'nsFormData'
},
{
'workers': True,
'skipGen': True,
'nativeType': 'JSObject'
}],
'GainNode': {
'resultNotAddRefed': [ 'gain' ],
},
'Geolocation': {
'headerFile': 'nsGeolocation.h'
},
'History': {
'headerFile': 'nsHistory.h',
'nativeType': 'nsHistory'
},
'HmacKeyAlgorithm': {
'resultNotAddRefed': ['hash']
},
'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',
},
'IDBFileRequest': {
'nativeType': 'mozilla::dom::indexedDB::IDBFileRequest',
},
'IDBIndex': {
'nativeType': 'mozilla::dom::indexedDB::IDBIndex',
'binaryNames': {
'mozGetAll': 'getAll',
'mozGetAllKeys': 'getAllKeys',
}
},
'IDBKeyRange': {
'nativeType': 'mozilla::dom::indexedDB::IDBKeyRange',
'wrapperCache': False,
},
'IDBMutableFile': {
'nativeType': 'mozilla::dom::indexedDB::IDBMutableFile',
},
'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,
}],
'InstallPhaseEvent': {
'headerFile': 'ServiceWorkerEvents.h',
'nativeType': 'mozilla::dom::workers::InstallPhaseEvent',
'workers': True
},
'InstallEvent': {
'headerFile': 'ServiceWorkerEvents.h',
'nativeType': 'mozilla::dom::workers::InstallEvent',
'workers': True
},
'Key': {
'resultNotAddRefed': ['algorithm']
},
'KeyEvent': {
'concrete': False
},
'LocalMediaStream': {
'headerFile': 'DOMMediaStream.h',
'nativeType': 'mozilla::DOMLocalMediaStream'
},
'Location': {
'nativeType': 'nsLocation',
},
'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
},
'MozCellBroadcast': {
'nativeType': 'mozilla::dom::CellBroadcast',
},
'MozIcc': {
'nativeType': 'mozilla::dom::Icc',
},
'MozIccManager': {
'nativeType': 'mozilla::dom::IccManager',
},
'MozMobileCellInfo': {
'nativeType': 'mozilla::dom::MobileCellInfo',
},
'MozMobileConnection': {
'nativeType': 'mozilla::dom::MobileConnection',
},
'MozMobileConnectionArray': {
'nativeType': 'mozilla::dom::MobileConnectionArray',
'resultNotAddRefed': [ 'item' ]
},
'MozMobileConnectionInfo': {
'nativeType': 'mozilla::dom::MobileConnectionInfo',
},
'MozMobileMessageManager': {
'nativeType': 'mozilla::dom::MobileMessageManager',
},
'MozMobileNetworkInfo': {
'nativeType': 'mozilla::dom::MobileNetworkInfo',
},
'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' ],
},
'PromiseDebugging': {
'concrete': False,
},
'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' ]
},
'RsaHashedKeyAlgorithm': {
'resultNotAddRefed': ['hash']
},
'Screen': {
'nativeType': 'nsScreen',
},
'Selection': {
'resultNotAddRefed': [ 'anchorNode', 'focusNode', 'getRangeAt' ],
},
'ShadowRoot': {
'resultNotAddRefed': [
'styleSheets'
]
},
'HTMLShadowElement': {
'resultNotAddRefed': [
'getOldShadowRoot'
]
},
'ServiceWorker': {
'nativeType': 'mozilla::dom::workers::ServiceWorker',
'headerFile': 'mozilla/dom/workers/bindings/ServiceWorker.h',
},
'ServiceWorkerContainer': {
'nativeType': 'mozilla::dom::workers::ServiceWorkerContainer',
'headerFile': 'mozilla/dom/ServiceWorkerContainer.h',
},
'ServiceWorkerGlobalScope': {
'headerFile': 'mozilla/dom/WorkerScope.h',
'workers': True,
},
'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' ],
},
'Storage': {
'nativeType': 'mozilla::dom::DOMStorage',
},
'StyleSheet': {
'nativeType': 'mozilla::CSSStyleSheet',
},
'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',
},
'SVGNumber': {
'nativeType': 'mozilla::DOMSVGNumber',
'headerFile': 'DOMSVGNumber.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'
},
'WebGLExtensionShaderTextureLod': {
'nativeType': 'mozilla::WebGLExtensionShaderTextureLod',
'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'
},
'WebGLExtensionBlendMinMax': {
'nativeType': 'mozilla::WebGLExtensionBlendMinMax',
'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',
'hasXPConnectImpls': True,
'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,
'implicitJSContext': ['getDataStores'],
},
'XMLHttpRequest': [
{
'nativeType': 'nsXMLHttpRequest',
'implicitJSContext': [ 'constructor', ],
'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
},
'XPathResult': {
'resultNotAddRefed': ['singleNodeValue', 'iterateNext', 'snapshotItem']
},
'XPathExpression': {
'wrapperCache': False,
'nativeOwnership': 'owned',
},
'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('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('MozMmsMessage')
addExternalIface('MozObserver', nativeType='nsIObserver', notflattened=True)
addExternalIface('MozRDFCompositeDataSource', nativeType='nsIRDFCompositeDataSource',
notflattened=True)
addExternalIface('MozRDFResource', nativeType='nsIRDFResource', notflattened=True)
addExternalIface('MozSmsFilter', headerFile='nsIDOMSmsFilter.h')
addExternalIface('MozSmsMessage')
addExternalIface('MozTreeBoxObject', nativeType='nsITreeBoxObject',
notflattened=True)
addExternalIface('MozTreeColumn', nativeType='nsITreeColumn',
headerFile='nsITreeColumns.h')
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('URI', nativeType='nsIURI', headerFile='nsIURI.h',
notflattened=True)
addExternalIface('UserDataHandler')
addExternalIface('XPathNSResolver')
addExternalIface('XULCommandDispatcher')