gecko-dev/dom/bindings/Bindings.conf

# 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 (required).
#   * headerFile - The file in which the nativeType is declared (defaults
#                  to an educated guess).
#   * castable - Indicates whether the value in the wrapper can be cast to
#                nativeType, or whether it needs to be QI-ed (defaults to True
#                for everything but callback interfaces).
#   * concrete - Indicates whether there exist objects with this interface as
#                their primary interface (defaults to True).
#   * prefable - Indicates whether this binding is subject to the about:config
#                pref, or whether it's always enabled (defaults to False).
#   * workers - Indicates whether the descriptor is intended to be used for
#               worker threads (defaults to false).
#   * customTrace - The native class will use a custom trace hook (defaults to
#                   true for workers, false otherwise).
#   * customFinalize - The native class will use a custom finalize hook
#                      (defaults to true for workers, false otherwise).
#   * 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 true for worker descriptors.
#                   Defaults to true.
#
#   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
#
#   * infallible - attributes and methods specified in the .webidl file that
#                  cannot fail and therefore do not require the final nsresult&
#                  argument
#   * 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

DOMInterfaces = {

'Blob': [
{
    'nativeType': 'nsIDOMBlob',
    'headerFile': 'nsIDOMFile.h',
    'prefable': True,
    'castable': False
},
{
    'workers': True,
    'nativeType': 'JSObject',
    'headerFile': 'jsapi.h',
    'castable': False
}],

'CanvasRenderingContext2D': [
{
    'nativeType': 'nsCanvasRenderingContext2DAzure',
    # Making this non-prefable requires that we ensure that nothing takes this
    # type as an argument or that the non-Azure variant is removed.
    'prefable': True,
    'infallible': {
        'all': [
            'canvas', 'save', 'restore', 'globalAlpha', 'shadowOffsetX',
            'shadowOffsetY', 'shadowBlur', 'shadowColor', 'clearRect',
            'fillRect', 'strokeRect', 'beginPath', 'fill', 'stroke', 'clip',
            'isPointInPath', 'lineWidth', 'lineCap', 'miterLimit', 'textAlign',
            'textBaseline', 'closePath', 'moveTo', 'lineTo', 'quadraticCurveTo',
            'bezierCurveTo', 'rect', 'mozFillRule', 'mozDashOffset',
            'mozImageSmoothingEnabled'
        ],
        'setterOnly': [
            'strokeStyle', 'fillStyle', 'lineJoin'
        ],
        'getterOnly': [
            'font', 'mozTextStyle'
        ]
    },
    'implicitJSContext': [
        'createImageData', 'getImageData', 'putImageData', 'strokeStyle',
        'fillStyle', 'mozDash'
    ],
    'resultNotAddRefed': [ 'canvas' ],
    'binaryNames': {
        'mozImageSmoothingEnabled': 'imageSmoothingEnabled',
        'mozFillRule': 'fillRule'
    }
}],

'Document': [
{
    'nativeType': 'nsIDocument',
    'prefable': True,
    'castable': False
},
{
    'workers': True,
    'nativeType': 'JSObject',
    'headerFile': 'jsapi.h',
    'castable': False
}],

'Event': [
{
    'nativeType': 'nsIDOMEvent',
    'prefable': True,
    'castable': False
},
{
    'workers': True,
    'nativeType': 'JSObject',
    'headerFile': 'jsapi.h',
    'castable': False
}],

'EventListener': [
{
    'nativeType': 'nsIDOMEventListener',
    'prefable': True
},
{
    'workers': True,
    'nativeType': 'JSObject',
    'headerFile': 'jsapi.h'
}],

'EventTarget': [
{
    'nativeType': 'nsDOMEventTargetHelper',
    'hasInstanceInterface': 'nsIDOMEventTarget',
    'concrete': False,
    'prefable': True,
},
{
    'workers': True,
    'nativeType': 'mozilla::dom::workers::EventTarget',
    'headerFile': 'mozilla/dom/workers/bindings/EventTarget.h',
    'concrete': False
}],

'FormData': [
{
    'nativeType': 'nsIDOMFormData',
    'prefable': True,
    'castable': False
},
{
    'workers': True,
    'nativeType': 'JSObject',
    'headerFile': 'jsapi.h',
    'castable': False
}],

'IID': [
{
    'nativeType': 'nsIJSIID',
    'headerFile': 'xpcjsid.h',
    'prefable': True,
    'castable': False
},
{
    'workers': True,
    'nativeType': 'JSObject',
    'headerFile': 'jsapi.h',
    'castable': False
}],

'InputStream': [
{
    'nativeType': 'nsIInputStream',
    'prefable': True,
    'castable': False,
    'notflattened': True
},
{
    'workers': True,
    'nativeType': 'JSObject',
    'headerFile': 'jsapi.h',
    'castable': False
}],

'MozChannel': [
{
    'nativeType': 'nsIChannel',
    'prefable': True,
    'castable': False,
    'notflattened': True
},
{
    'workers': True,
    'nativeType': 'JSObject',
    'headerFile': 'jsapi.h',
    'castable': False
}],

'WebGLRenderingContext': {
  'nativeType': 'mozilla::WebGLContext',
  'headerFile': 'WebGLContext.h',
  'prefable': True,
  'resultNotAddRefed': [ 'canvas', 'getContextAttributes', 'getExtension',
                         'getAttachedShaders' ],
  'implicitJSContext': [ 'texImage2D', 'texSubImage2D' ],
  'infallible': [ 'canvas', 'drawingBufferWidth', 'drawingBufferHeight',
                  'isContextLost', 'getSupportedExtensions',
                  'getExtension', 'activeTexture',
                  'attachShader', 'bindAttribLocation', 'bindBuffer',
                  'bindFramebuffer', 'bindRenderbuffer', 'bindTexture',
                  'blendColor', 'blendEquation', 'blendEquationSeparate',
                  'blendFunc', 'blendFuncSeparate', 'bufferData',
                  'bufferSubData', 'checkFramebufferStatus',
                  'clear', 'clearColor', 'clearDepth', 'clearStencil',
                  'colorMask', 'compileShader', 'compressedTexImage2D',
                  'compressedTexSubImage2D', 'copyTexImage2D',
                  'copyTexSubImage2D', 'createBuffer', 'createFramebuffer',
                  'createProgram', 'createRenderbuffer', 'createShader',
                  'createTexture', 'cullFace', 'deleteBuffer',
                  'deleteFramebuffer', 'deleteProgram', 'deleteRenderbuffer',
                  'deleteShader', 'deleteTexture', 'depthFunc', 'depthMask',
                  'depthRange', 'detachShader', 'disable',
                  'disableVertexAttribArray', 'drawArrays', 'drawElements',
                  'enable', 'enableVertexAttribArray', 'finish', 'flush',
                  'framebufferRenderbuffer', 'framebufferTexture2D',
                  'frontFace', 'generateMipmap', 'getActiveAttrib',
                  'getActiveUniform', 'getAttachedShaders', 'getAttribLocation',
                  'getBufferParameter', 'getError', 'getProgramParameter',
                  'getRenderbufferParameter', 'getShaderParameter',
                  'getShaderPrecisionFormat', 'getShaderSource',
                  'getTexParameter', 'getUniformLocation',
                  'getVertexAttribOffset', 'hint', 'isBuffer',
                  'isEnabled', 'isFramebuffer', 'isProgram', 'isRenderbuffer',
                  'isShader', 'isTexture', 'lineWidth', 'pixelStorei',
                  'polygonOffset', 'renderbufferStorage', 'sampleCoverage',
                  'scissor', 'shaderSource', 'stencilFunc',
                  'stencilFuncSeparate', 'stencilMask', 'stencilMaskSeparate',
                  'stencilOp', 'stencilOpSeparate', 'texParameterf',
                  'texParameteri', 'uniform1f', 'uniform1fv', 'uniform1i',
                  'uniform1iv', 'uniform2f', 'uniform2fv', 'uniform2i',
                  'uniform2iv', 'uniform3f', 'uniform3fv', 'uniform3i',
                  'uniform3iv', 'uniform4f', 'uniform4fv', 'uniform4i',
                  'uniform4iv', 'uniformMatrix2fv', 'uniformMatrix3fv',
                  'uniformMatrix4fv', 'useProgram', 'validateProgram',
                  'vertexAttrib1f', 'vertexAttrib1fv', 'vertexAttrib2f',
                  'vertexAttrib2fv', 'vertexAttrib3f', 'vertexAttrib3fv',
                  'vertexAttrib4f', 'vertexAttrib4fv', 'vertexAttribPointer',
                  'viewport'
                  ]
},

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

'XMLHttpRequest': [
{
    'nativeType': 'nsXMLHttpRequest',
    'prefable': True,
    'infallible': {
        'all': [
            'readyState', 'withCredentials', 'abort', 'statusText',
            'getAllResponseHeaders', 'overrideMimeType', 'mozBackgroundRequest',
            'multipart', 'channel', 'upload', 'status', 'mozAnon', 'mozSystem'
        ],
        'getterOnly': [
            'responseType', 'timeout', 'onreadystatechange', 'onuploadprogress'
        ]
    },
    'implicitJSContext': [ 'constructor', ],
    'resultNotAddRefed': [ 'upload', 'responseXML' ]
},
{
    'workers': True,
    'nativeType': 'mozilla::dom::workers::XMLHttpRequest',
    'headerFile': 'mozilla/dom/workers/bindings/XMLHttpRequest.h',
    'infallible': {
        'all': ['readyState', 'statusText', 'mozAnon', 'mozSystem' ],
        'getterOnly': [ 'timeout', 'withCredentials', 'mozBackgroundRequest',
                        'responseType', 'responseXML', 'channel', 'multipart' ]
    }

}],

'XMLHttpRequestEventTarget': [
{
    'nativeType': 'nsXHREventTarget',
    'headerFile': 'nsXMLHttpRequest.h',
    'concrete': False,
    'prefable': True,
    'infallible': {
        'getterOnly': [
            'onabort', 'onerror', 'onload', 'onloadstart', 'onprogress',
            'ontimeout', 'onloadend'
        ]
    },
},
{
    'workers': True,
    'concrete': False,
    'nativeType': 'mozilla::dom::workers::XMLHttpRequestEventTarget',
    'headerFile': 'mozilla/dom/workers/bindings/XMLHttpRequestEventTarget.h'
}],

'XMLHttpRequestUpload': [
{
    'nativeType': 'nsXMLHttpRequestUpload',
    'headerFile': 'nsXMLHttpRequest.h',
    'prefable': True
},
{
    'workers': True,
    'nativeType': 'mozilla::dom::workers::XMLHttpRequestUpload',
    'headerFile': 'mozilla/dom/workers/bindings/XMLHttpRequestUpload.h'
}],

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

'TestInterface' : {
        'nativeType': 'mozilla::dom::TestInterface',
        'headerFile': 'TestBindingHeader.h',
        'register': False,
        'resultNotAddRefed': [ 'receiveWeakSelf', 'receiveWeakNullableSelf',
                               'receiveWeakCastableObjectSequence',
                               'receiveWeakNullableCastableObjectSequence',
                               'receiveWeakCastableObjectNullableSequence',
                               'receiveWeakNullableCastableObjectNullableSequence' ],
        'binaryNames': { 'methodRenamedFrom': 'methodRenamedTo',
                         'attributeGetterRenamedFrom': 'attributeGetterRenamedTo',
                         'attributeRenamedFrom': 'attributeRenamedTo' }
        },

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

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

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

# These are temporary, until they've been converted to use new DOM bindings
def addExternalIface(iface, nativeType=None, headerFile=None):
    if nativeType is None:
        nativeType = 'nsIDOM' + iface
    domInterface = {
        'nativeType': nativeType,
        'concrete': False,
        'castable': False
    }
    if not headerFile is None:
        domInterface['headerFile'] = headerFile
    DOMInterfaces[iface] = domInterface

# If you add one of these, you need to make sure nsDOMQS.h has the relevant
# macros added for it
def addExternalHTMLElement(element):
   nativeElement = 'ns' + element
   addExternalIface(element, nativeType=nativeElement,
                    headerFile=nativeElement + '.h')

addExternalHTMLElement('HTMLCanvasElement')
addExternalHTMLElement('HTMLImageElement')
addExternalHTMLElement('HTMLVideoElement')
addExternalIface('CanvasGradient', headerFile='nsIDOMCanvasRenderingContext2D.h')
addExternalIface('CanvasPattern', headerFile='nsIDOMCanvasRenderingContext2D.h')
addExternalIface('HitRegionOptions', nativeType='nsISupports')
addExternalIface('ImageData', nativeType='mozilla::dom::ImageData')
addExternalIface('TextMetrics', headerFile='nsIDOMCanvasRenderingContext2D.h')
addExternalIface('WebGLActiveInfo', nativeType='mozilla::WebGLActiveInfo',
                 headerFile='WebGLContext.h')
addExternalIface('WebGLBuffer', nativeType='mozilla::WebGLBuffer',
                 headerFile='WebGLContext.h')
addExternalIface('WebGLContextAttributes', nativeType='JSObject',
                 headerFile='jsapi.h')
addExternalIface('WebGLExtension', nativeType='nsIWebGLExtension',
                 headerFile='WebGLContext.h')
addExternalIface('WebGLFramebuffer', nativeType='mozilla::WebGLFramebuffer',
                 headerFile='WebGLContext.h')
addExternalIface('WebGLProgram', nativeType='mozilla::WebGLProgram',
                 headerFile='WebGLContext.h')
addExternalIface('WebGLRenderbuffer', nativeType='mozilla::WebGLRenderbuffer',
                 headerFile='WebGLContext.h')
addExternalIface('WebGLShader', nativeType='mozilla::WebGLShader',
                 headerFile='WebGLContext.h')
addExternalIface('WebGLShaderPrecisionFormat',
                 nativeType='mozilla::WebGLShaderPrecisionFormat',
                 headerFile='WebGLContext.h')
addExternalIface('WebGLTexture', nativeType='mozilla::WebGLTexture',
                 headerFile='WebGLContext.h')
addExternalIface('Window')
addExternalIface('XULElement')