summaryrefslogtreecommitdiffstats
path: root/dom/bindings/Configuration.py
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--dom/bindings/Configuration.py1454
1 files changed, 1454 insertions, 0 deletions
diff --git a/dom/bindings/Configuration.py b/dom/bindings/Configuration.py
new file mode 100644
index 0000000000..266a8db34a
--- /dev/null
+++ b/dom/bindings/Configuration.py
@@ -0,0 +1,1454 @@
+# 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/.
+
+import io
+import itertools
+import os
+from collections import defaultdict
+
+import six
+from WebIDL import IDLIncludesStatement
+
+autogenerated_comment = "/* THIS FILE IS AUTOGENERATED - DO NOT EDIT */\n"
+
+
+def toStringBool(arg):
+ """
+ Converts IDL/Python Boolean (True/False) to C++ Boolean (true/false)
+ """
+ return str(not not arg).lower()
+
+
+class DescriptorProvider:
+ """
+ A way of getting descriptors for interface names. Subclasses must
+ have a getDescriptor method callable with the interface name only.
+
+ Subclasses must also have a getConfig() method that returns a
+ Configuration.
+ """
+
+ def __init__(self):
+ pass
+
+
+def isChildPath(path, basePath):
+ path = os.path.normpath(path)
+ return os.path.commonprefix((path, basePath)) == basePath
+
+
+class Configuration(DescriptorProvider):
+ """
+ Represents global configuration state based on IDL parse data and
+ the configuration file.
+ """
+
+ def __init__(self, filename, webRoots, parseData, generatedEvents=[]):
+ DescriptorProvider.__init__(self)
+
+ # Read the configuration file.
+ glbl = {}
+ exec(io.open(filename, encoding="utf-8").read(), glbl)
+ config = glbl["DOMInterfaces"]
+
+ class IDLAttrGetterOrSetterTemplate:
+ def __init__(self, template, getter, setter, argument, attrName):
+ class TemplateAdditionalArg:
+ def __init__(self, type, name, value=None):
+ self.type = type
+ self.name = name
+ self.value = value
+
+ self.descriptor = None
+ self.usedInOtherInterfaces = False
+ self.getter = getter
+ self.setter = setter
+ self.argument = TemplateAdditionalArg(*argument)
+ self.attrNameString = attrName
+ self.attr = None
+
+ self.attributeTemplates = dict()
+ attributeTemplatesByInterface = dict()
+ for interface, templates in glbl["TemplatedAttributes"].items():
+ for template in templates:
+ name = template.get("template")
+ t = IDLAttrGetterOrSetterTemplate(**template)
+ self.attributeTemplates[name] = t
+ attributeTemplatesByInterface.setdefault(interface, list()).append(t)
+
+ webRoots = tuple(map(os.path.normpath, webRoots))
+
+ def isInWebIDLRoot(path):
+ return any(isChildPath(path, root) for root in webRoots)
+
+ # Build descriptors for all the interfaces we have in the parse data.
+ # This allows callers to specify a subset of interfaces by filtering
+ # |parseData|.
+ self.descriptors = []
+ self.interfaces = {}
+ self.descriptorsByName = {}
+ self.dictionariesByName = {}
+ self.generatedEvents = generatedEvents
+ self.maxProtoChainLength = 0
+ for thing in parseData:
+ if isinstance(thing, IDLIncludesStatement):
+ # Our build system doesn't support dep build involving
+ # addition/removal of "includes" statements that appear in a
+ # different .webidl file than their LHS interface. Make sure we
+ # don't have any of those. See similar block below for partial
+ # interfaces!
+ if thing.interface.filename() != thing.filename():
+ raise TypeError(
+ "The binding build system doesn't really support "
+ "'includes' statements which don't appear in the "
+ "file in which the left-hand side of the statement is "
+ "defined.\n"
+ "%s\n"
+ "%s" % (thing.location, thing.interface.location)
+ )
+
+ assert not thing.isType()
+
+ if (
+ not thing.isInterface()
+ and not thing.isNamespace()
+ and not thing.isInterfaceMixin()
+ ):
+ continue
+ # Our build system doesn't support dep builds involving
+ # addition/removal of partial interfaces/namespaces/mixins that
+ # appear in a different .webidl file than the
+ # interface/namespace/mixin they are extending. Make sure we don't
+ # have any of those. See similar block above for "includes"
+ # statements!
+ if not thing.isExternal():
+ for partial in thing.getPartials():
+ if partial.filename() != thing.filename():
+ raise TypeError(
+ "The binding build system doesn't really support "
+ "partial interfaces/namespaces/mixins which don't "
+ "appear in the file in which the "
+ "interface/namespace/mixin they are extending is "
+ "defined. Don't do this.\n"
+ "%s\n"
+ "%s" % (partial.location, thing.location)
+ )
+
+ # The rest of the logic doesn't apply to mixins.
+ if thing.isInterfaceMixin():
+ continue
+
+ iface = thing
+ if not iface.isExternal():
+ if not (
+ iface.getExtendedAttribute("ChromeOnly")
+ or iface.getExtendedAttribute("Func")
+ == ["nsContentUtils::IsCallerChromeOrFuzzingEnabled"]
+ or not iface.hasInterfaceObject()
+ or isInWebIDLRoot(iface.filename())
+ ):
+ raise TypeError(
+ "Interfaces which are exposed to the web may only be "
+ "defined in a DOM WebIDL root %r. Consider marking "
+ "the interface [ChromeOnly] or "
+ "[Func='nsContentUtils::IsCallerChromeOrFuzzingEnabled'] "
+ "if you do not want it exposed to the web.\n"
+ "%s" % (webRoots, iface.location)
+ )
+
+ self.interfaces[iface.identifier.name] = iface
+
+ entry = config.pop(iface.identifier.name, {})
+ assert not isinstance(entry, list)
+
+ desc = Descriptor(
+ self,
+ iface,
+ entry,
+ attributeTemplatesByInterface.get(iface.identifier.name),
+ )
+ self.descriptors.append(desc)
+ # Setting up descriptorsByName while iterating through interfaces
+ # means we can get the nativeType of iterable interfaces without
+ # having to do multiple loops.
+ assert desc.interface.identifier.name not in self.descriptorsByName
+ self.descriptorsByName[desc.interface.identifier.name] = desc
+
+ if len(config) > 0:
+ raise NoSuchDescriptorError(
+ "Bindings.conf contains entries for "
+ + str(list(config))
+ + " that aren't declared as interfaces in the .webidl files."
+ )
+
+ # Keep the descriptor list sorted for determinism.
+ self.descriptors.sort(key=lambda x: x.name)
+
+ self.descriptorsByFile = {}
+ for d in self.descriptors:
+ self.descriptorsByFile.setdefault(d.interface.filename(), []).append(d)
+
+ self.enums = [e for e in parseData if e.isEnum()]
+
+ self.dictionaries = [d for d in parseData if d.isDictionary()]
+ self.dictionariesByName = {d.identifier.name: d for d in self.dictionaries}
+
+ self.callbacks = [
+ c for c in parseData if c.isCallback() and not c.isInterface()
+ ]
+
+ # Dictionary mapping from a union type name to a set of filenames where
+ # union types with that name are used.
+ self.filenamesPerUnion = defaultdict(set)
+
+ # Dictionary mapping from a filename to a list of types for
+ # the union types used in that file. If a union type is used
+ # in multiple files then it will be added to the list for the
+ # None key. Note that the list contains a type for every use
+ # of a union type, so there can be multiple entries with union
+ # types that have the same name.
+ self.unionsPerFilename = defaultdict(list)
+
+ def addUnion(t):
+ filenamesForUnion = self.filenamesPerUnion[t.name]
+ if t.filename() not in filenamesForUnion:
+ # We have a to be a bit careful: some of our built-in
+ # typedefs are for unions, and those unions end up with
+ # "<unknown>" as the filename. If that happens, we don't
+ # want to try associating this union with one particular
+ # filename, since there isn't one to associate it with,
+ # really.
+ if t.filename() == "<unknown>":
+ uniqueFilenameForUnion = None
+ elif len(filenamesForUnion) == 0:
+ # This is the first file that we found a union with this
+ # name in, record the union as part of the file.
+ uniqueFilenameForUnion = t.filename()
+ else:
+ # We already found a file that contains a union with
+ # this name.
+ if len(filenamesForUnion) == 1:
+ # This is the first time we found a union with this
+ # name in another file.
+ for f in filenamesForUnion:
+ # Filter out unions with this name from the
+ # unions for the file where we previously found
+ # them.
+ unionsForFilename = [
+ u for u in self.unionsPerFilename[f] if u.name != t.name
+ ]
+ if len(unionsForFilename) == 0:
+ del self.unionsPerFilename[f]
+ else:
+ self.unionsPerFilename[f] = unionsForFilename
+ # Unions with this name appear in multiple files, record
+ # the filename as None, so that we can detect that.
+ uniqueFilenameForUnion = None
+ self.unionsPerFilename[uniqueFilenameForUnion].append(t)
+ filenamesForUnion.add(t.filename())
+
+ def addUnions(t):
+ t = findInnermostType(t)
+ if t.isUnion():
+ addUnion(t)
+ for m in t.flatMemberTypes:
+ addUnions(m)
+
+ for t, _ in getAllTypes(self.descriptors, self.dictionaries, self.callbacks):
+ addUnions(t)
+
+ for d in getDictionariesConvertedToJS(
+ self.descriptors, self.dictionaries, self.callbacks
+ ):
+ d.needsConversionToJS = True
+
+ for d in getDictionariesConvertedFromJS(
+ self.descriptors, self.dictionaries, self.callbacks
+ ):
+ d.needsConversionFromJS = True
+
+ # Collect all the global names exposed on a Window object (to implement
+ # the hash for looking up these names when resolving a property).
+ self.windowGlobalNames = []
+ for desc in self.getDescriptors(registersGlobalNamesOnWindow=True):
+ self.windowGlobalNames.append((desc.name, desc))
+ self.windowGlobalNames.extend(
+ (n.identifier.name, desc) for n in desc.interface.legacyFactoryFunctions
+ )
+ self.windowGlobalNames.extend(
+ (n, desc) for n in desc.interface.legacyWindowAliases
+ )
+
+ # Collect a sorted list of strings that we want to concatenate into
+ # one big string and a dict mapping each string to its offset in the
+ # concatenated string.
+
+ # We want the names of all the interfaces with a prototype (for
+ # implementing @@toStringTag).
+ names = set(
+ d.interface.getClassName()
+ for d in self.getDescriptors(hasInterfaceOrInterfacePrototypeObject=True)
+ )
+
+ # Now also add the names from windowGlobalNames, we need them for the
+ # perfect hash that we build for these.
+ names.update(n[0] for n in self.windowGlobalNames)
+
+ # Sorting is not strictly necessary, but makes the generated code a bit
+ # more readable.
+ names = sorted(names)
+
+ # We can't rely on being able to pass initial=0 to itertools.accumulate
+ # because it was only added in version 3.8, so define an accumulate
+ # function that chains the initial value into the iterator.
+ def accumulate(iterable, initial):
+ return itertools.accumulate(itertools.chain([initial], iterable))
+
+ # Calculate the offset of each name in the concatenated string. Note that
+ # we need to add 1 to the length to account for the null terminating each
+ # name.
+ offsets = accumulate(map(lambda n: len(n) + 1, names), initial=0)
+ self.namesStringOffsets = list(zip(names, offsets))
+
+ allTemplatedAttributes = (
+ (m, d)
+ for d in self.descriptors
+ if not d.interface.isExternal()
+ for m in d.interface.members
+ if m.isAttr() and m.getExtendedAttribute("BindingTemplate") is not None
+ )
+ # attributesPerTemplate will have the template names as keys, and a
+ # list of tuples as values. Every tuple contains an IDLAttribute and a
+ # descriptor.
+ attributesPerTemplate = dict()
+ for m, d in allTemplatedAttributes:
+ t = m.getExtendedAttribute("BindingTemplate")
+ if isinstance(t[0], list):
+ t = t[0]
+ l = attributesPerTemplate.setdefault(t[0], list())
+ # We want the readonly attributes last, because we use the first
+ # attribute in the list as the canonical attribute for the
+ # template, and if there are any writable attributes the
+ # template should have support for that.
+ if not m.readonly:
+ l.insert(0, (m, d))
+ else:
+ l.append((m, d))
+
+ for name, attributes in attributesPerTemplate.items():
+ # We use the first attribute to generate a canonical implementation
+ # of getter and setter.
+ firstAttribute, firstDescriptor = attributes[0]
+ template = self.attributeTemplates.get(name)
+ if template is None:
+ raise TypeError(
+ "Unknown BindingTemplate with name %s for %s on %s"
+ % (
+ name,
+ firstAttribute.identifier.name,
+ firstDescriptor.interface.identifier.name,
+ )
+ )
+
+ # This mimics a real IDL attribute for templated bindings.
+ class TemplateIDLAttribute:
+ def __init__(self, attr):
+ assert attr.isAttr()
+ assert not attr.isMaplikeOrSetlikeAttr()
+ assert not attr.slotIndices
+
+ self.identifier = attr.identifier
+ self.type = attr.type
+ self.extendedAttributes = attr.getExtendedAttributes()
+ self.slotIndices = None
+
+ def getExtendedAttribute(self, name):
+ return self.extendedAttributes.get(name)
+
+ def isAttr(self):
+ return True
+
+ def isMaplikeOrSetlikeAttr(self):
+ return False
+
+ def isMethod(self):
+ return False
+
+ def isStatic(self):
+ return False
+
+ template.attr = TemplateIDLAttribute(firstAttribute)
+
+ def filterExtendedAttributes(extendedAttributes):
+ # These are the extended attributes that we allow to have
+ # different values among all attributes that use the same
+ # template.
+ ignoredAttributes = {
+ "BindingTemplate",
+ "BindingAlias",
+ "ChromeOnly",
+ "Pure",
+ "Pref",
+ "Func",
+ "Throws",
+ "GetterThrows",
+ "SetterThrows",
+ }
+ return dict(
+ filter(
+ lambda i: i[0] not in ignoredAttributes,
+ extendedAttributes.items(),
+ )
+ )
+
+ firstExtAttrs = filterExtendedAttributes(
+ firstAttribute.getExtendedAttributes()
+ )
+
+ for a, d in attributes:
+ # We want to make sure all getters or setters grouped by a
+ # template have the same WebIDL signatures, so make sure
+ # their types are the same.
+ if template.attr.type != a.type:
+ raise TypeError(
+ "%s on %s and %s on %s have different type, but they're using the same template %s."
+ % (
+ firstAttribute.identifier.name,
+ firstDescriptor.interface.identifier.name,
+ a.identifier.name,
+ d.interface.identifier.name,
+ name,
+ )
+ )
+
+ extAttrs = filterExtendedAttributes(a.getExtendedAttributes())
+ if template.attr.extendedAttributes != extAttrs:
+ for k in extAttrs.keys() - firstExtAttrs.keys():
+ raise TypeError(
+ "%s on %s has extended attribute %s and %s on %s does not, but they're using the same template %s."
+ % (
+ a.identifier.name,
+ d.interface.identifier.name,
+ k,
+ firstAttribute.identifier.name,
+ firstDescriptor.interface.identifier.name,
+ name,
+ )
+ )
+ for k in firstExtAttrs.keys() - extAttrs.keys():
+ raise TypeError(
+ "%s on %s has extended attribute %s and %s on %s does not, but they're using the same template %s."
+ % (
+ firstAttribute.identifier.name,
+ firstDescriptor.interface.identifier.name,
+ k,
+ a.identifier.name,
+ d.interface.identifier.name,
+ name,
+ )
+ )
+ for k, v in firstExtAttrs.items():
+ if extAttrs[k] != v:
+ raise TypeError(
+ "%s on %s and %s on %s have different values for extended attribute %s, but they're using the same template %s."
+ % (
+ firstAttribute.identifier.name,
+ firstDescriptor.interface.identifier.name,
+ a.identifier.name,
+ d.interface.identifier.name,
+ k,
+ name,
+ )
+ )
+
+ def sameThrows(getter=False, setter=False):
+ extAttrs1 = firstDescriptor.getExtendedAttributes(
+ firstAttribute, getter=getter, setter=setter
+ )
+ extAttrs2 = d.getExtendedAttributes(a, getter=getter, setter=setter)
+ return ("needsErrorResult" in extAttrs1) == (
+ "needsErrorResult" in extAttrs2
+ )
+
+ if not sameThrows(getter=True) or (
+ not a.readonly and not sameThrows(setter=True)
+ ):
+ raise TypeError(
+ "%s on %s and %s on %s have different annotations about throwing, but they're using the same template %s."
+ % (
+ firstAttribute.identifier.name,
+ firstDescriptor.interface.identifier.name,
+ a.identifier.name,
+ d.interface.identifier.name,
+ name,
+ )
+ )
+
+ for name, template in self.attributeTemplates.items():
+ if template.attr is None:
+ print("Template %s is unused, please remove it." % name)
+
+ def getInterface(self, ifname):
+ return self.interfaces[ifname]
+
+ def getDescriptors(self, **filters):
+ """Gets the descriptors that match the given filters."""
+ curr = self.descriptors
+ # Collect up our filters, because we may have a webIDLFile filter that
+ # we always want to apply first.
+ tofilter = [(lambda x: x.interface.isExternal(), False)]
+ for key, val in six.iteritems(filters):
+ if key == "webIDLFile":
+ # Special-case this part to make it fast, since most of our
+ # getDescriptors calls are conditioned on a webIDLFile. We may
+ # not have this key, in which case we have no descriptors
+ # either.
+ curr = self.descriptorsByFile.get(val, [])
+ continue
+ elif key == "hasInterfaceObject":
+
+ def getter(x):
+ return x.interface.hasInterfaceObject()
+
+ elif key == "hasInterfacePrototypeObject":
+
+ def getter(x):
+ return x.interface.hasInterfacePrototypeObject()
+
+ elif key == "hasInterfaceOrInterfacePrototypeObject":
+
+ def getter(x):
+ return x.hasInterfaceOrInterfacePrototypeObject()
+
+ elif key == "isCallback":
+
+ def getter(x):
+ return x.interface.isCallback()
+
+ elif key == "isJSImplemented":
+
+ def getter(x):
+ return x.interface.isJSImplemented()
+
+ elif key == "isExposedInAnyWorker":
+
+ def getter(x):
+ return x.interface.isExposedInAnyWorker()
+
+ elif key == "isExposedInWorkerDebugger":
+
+ def getter(x):
+ return x.interface.isExposedInWorkerDebugger()
+
+ elif key == "isExposedInAnyWorklet":
+
+ def getter(x):
+ return x.interface.isExposedInAnyWorklet()
+
+ elif key == "isExposedInWindow":
+
+ def getter(x):
+ return x.interface.isExposedInWindow()
+
+ elif key == "isExposedInShadowRealms":
+
+ def getter(x):
+ return x.interface.isExposedInShadowRealms()
+
+ elif key == "isSerializable":
+
+ def getter(x):
+ return x.interface.isSerializable()
+
+ else:
+ # Have to watch out: just closing over "key" is not enough,
+ # since we're about to mutate its value
+ getter = (lambda attrName: lambda x: getattr(x, attrName))(key)
+ tofilter.append((getter, val))
+ for f in tofilter:
+ curr = [x for x in curr if f[0](x) == f[1]]
+ return curr
+
+ def getEnums(self, webIDLFile):
+ return [e for e in self.enums if e.filename() == webIDLFile]
+
+ def getDictionaries(self, webIDLFile):
+ return [d for d in self.dictionaries if d.filename() == webIDLFile]
+
+ def getCallbacks(self, webIDLFile):
+ return [c for c in self.callbacks if c.filename() == webIDLFile]
+
+ def getDescriptor(self, interfaceName):
+ """
+ Gets the appropriate descriptor for the given interface name.
+ """
+ # We may have optimized out this descriptor, but the chances of anyone
+ # asking about it are then slim. Put the check for that _after_ we've
+ # done our normal lookup. But that means we have to do our normal
+ # lookup in a way that will not throw if it fails.
+ d = self.descriptorsByName.get(interfaceName, None)
+ if d:
+ return d
+
+ raise NoSuchDescriptorError("For " + interfaceName + " found no matches")
+
+ def getConfig(self):
+ return self
+
+ def getDictionariesConvertibleToJS(self):
+ return [d for d in self.dictionaries if d.needsConversionToJS]
+
+ def getDictionariesConvertibleFromJS(self):
+ return [d for d in self.dictionaries if d.needsConversionFromJS]
+
+ def getDictionaryIfExists(self, dictionaryName):
+ return self.dictionariesByName.get(dictionaryName, None)
+
+
+class NoSuchDescriptorError(TypeError):
+ def __init__(self, str):
+ TypeError.__init__(self, str)
+
+
+def methodReturnsJSObject(method):
+ assert method.isMethod()
+
+ for signature in method.signatures():
+ returnType = signature[0]
+ if returnType.isObject() or returnType.isSpiderMonkeyInterface():
+ return True
+
+ return False
+
+
+def MemberIsLegacyUnforgeable(member, descriptor):
+ # Note: "or" and "and" return either their LHS or RHS, not
+ # necessarily booleans. Make sure to return a boolean from this
+ # method, because callers will compare its return value to
+ # booleans.
+ return bool(
+ (member.isAttr() or member.isMethod())
+ and not member.isStatic()
+ and (
+ member.isLegacyUnforgeable()
+ or descriptor.interface.getExtendedAttribute("LegacyUnforgeable")
+ )
+ )
+
+
+class Descriptor(DescriptorProvider):
+ """
+ Represents a single descriptor for an interface. See Bindings.conf.
+ """
+
+ def __init__(self, config, interface, desc, attributeTemplates):
+ DescriptorProvider.__init__(self)
+ self.config = config
+ self.interface = interface
+ self.attributeTemplates = attributeTemplates
+ if self.attributeTemplates is not None:
+ for t in self.attributeTemplates:
+ t.descriptor = self
+
+ self.wantsXrays = not interface.isExternal() and interface.isExposedInWindow()
+
+ if self.wantsXrays:
+ # We could try to restrict self.wantsXrayExpandoClass further. For
+ # example, we could set it to false if all of our slots store
+ # Gecko-interface-typed things, because we don't use Xray expando
+ # slots for those. But note that we would need to check the types
+ # of not only the members of "interface" but also of all its
+ # ancestors, because those can have members living in our slots too.
+ # For now, do the simple thing.
+ self.wantsXrayExpandoClass = interface.totalMembersInSlots != 0
+
+ # Read the desc, and fill in the relevant defaults.
+ ifaceName = self.interface.identifier.name
+ # For generated iterator interfaces for other iterable interfaces, we
+ # just use IterableIterator as the native type, templated on the
+ # nativeType of the iterable interface. That way we can have a
+ # templated implementation for all the duplicated iterator
+ # functionality.
+ if self.interface.isIteratorInterface():
+ itrName = self.interface.iterableInterface.identifier.name
+ itrDesc = self.getDescriptor(itrName)
+ nativeTypeDefault = iteratorNativeType(itrDesc)
+ elif self.interface.isAsyncIteratorInterface():
+ itrName = self.interface.asyncIterableInterface.identifier.name
+ itrDesc = self.getDescriptor(itrName)
+ nativeTypeDefault = iteratorNativeType(itrDesc)
+
+ elif self.interface.isExternal():
+ nativeTypeDefault = "nsIDOM" + ifaceName
+ else:
+ nativeTypeDefault = "mozilla::dom::" + ifaceName
+
+ self.nativeType = desc.get("nativeType", nativeTypeDefault)
+ # Now create a version of nativeType that doesn't have extra
+ # mozilla::dom:: at the beginning.
+ prettyNativeType = self.nativeType.split("::")
+ if prettyNativeType[0] == "mozilla":
+ prettyNativeType.pop(0)
+ if prettyNativeType[0] == "dom":
+ prettyNativeType.pop(0)
+ self.prettyNativeType = "::".join(prettyNativeType)
+
+ self.jsImplParent = desc.get("jsImplParent", self.nativeType)
+
+ # Do something sane for JSObject
+ if self.nativeType == "JSObject":
+ headerDefault = "js/TypeDecls.h"
+ elif self.interface.isCallback() or self.interface.isJSImplemented():
+ # A copy of CGHeaders.getDeclarationFilename; we can't
+ # import it here, sadly.
+ # Use our local version of the header, not the exported one, so that
+ # test bindings, which don't export, will work correctly.
+ basename = os.path.basename(self.interface.filename())
+ headerDefault = basename.replace(".webidl", "Binding.h")
+ else:
+ if not self.interface.isExternal() and self.interface.getExtendedAttribute(
+ "HeaderFile"
+ ):
+ headerDefault = self.interface.getExtendedAttribute("HeaderFile")[0]
+ elif (
+ self.interface.isIteratorInterface()
+ or self.interface.isAsyncIteratorInterface()
+ ):
+ headerDefault = "mozilla/dom/IterableIterator.h"
+ else:
+ headerDefault = self.nativeType
+ headerDefault = headerDefault.replace("::", "/") + ".h"
+ self.headerFile = desc.get("headerFile", headerDefault)
+ self.headerIsDefault = self.headerFile == headerDefault
+ if self.jsImplParent == self.nativeType:
+ self.jsImplParentHeader = self.headerFile
+ else:
+ self.jsImplParentHeader = self.jsImplParent.replace("::", "/") + ".h"
+
+ self.notflattened = desc.get("notflattened", False)
+ self.register = desc.get("register", True)
+
+ # If we're concrete, we need to crawl our ancestor interfaces and mark
+ # them as having a concrete descendant.
+ concreteDefault = (
+ not self.interface.isExternal()
+ and not self.interface.isCallback()
+ and not self.interface.isNamespace()
+ and
+ # We're going to assume that leaf interfaces are
+ # concrete; otherwise what's the point? Also
+ # interfaces with constructors had better be
+ # concrete; otherwise how can you construct them?
+ (
+ not self.interface.hasChildInterfaces()
+ or self.interface.ctor() is not None
+ )
+ )
+
+ self.concrete = desc.get("concrete", concreteDefault)
+ self.hasLegacyUnforgeableMembers = self.concrete and any(
+ MemberIsLegacyUnforgeable(m, self) for m in self.interface.members
+ )
+ self.operations = {
+ "IndexedGetter": None,
+ "IndexedSetter": None,
+ "IndexedDeleter": None,
+ "NamedGetter": None,
+ "NamedSetter": None,
+ "NamedDeleter": None,
+ "Stringifier": None,
+ "LegacyCaller": None,
+ }
+
+ self.hasDefaultToJSON = False
+
+ # Stringifiers need to be set up whether an interface is
+ # concrete or not, because they're actually prototype methods and hence
+ # can apply to instances of descendant interfaces. Legacy callers and
+ # named/indexed operations only need to be set up on concrete
+ # interfaces, since they affect the JSClass we end up using, not the
+ # prototype object.
+ def addOperation(operation, m):
+ if not self.operations[operation]:
+ self.operations[operation] = m
+
+ # Since stringifiers go on the prototype, we only need to worry
+ # about our own stringifier, not those of our ancestor interfaces.
+ if not self.interface.isExternal():
+ for m in self.interface.members:
+ if m.isMethod() and m.isStringifier():
+ addOperation("Stringifier", m)
+ if m.isMethod() and m.isDefaultToJSON():
+ self.hasDefaultToJSON = True
+
+ # We keep track of instrumente props for all non-external interfaces.
+ self.instrumentedProps = []
+ instrumentedProps = self.interface.getExtendedAttribute("InstrumentedProps")
+ if instrumentedProps:
+ # It's actually a one-element list, with the list
+ # we want as the only element.
+ self.instrumentedProps = instrumentedProps[0]
+
+ # Check that we don't have duplicated instrumented props.
+ uniqueInstrumentedProps = set(self.instrumentedProps)
+ if len(uniqueInstrumentedProps) != len(self.instrumentedProps):
+ duplicates = [
+ p
+ for p in uniqueInstrumentedProps
+ if self.instrumentedProps.count(p) > 1
+ ]
+ raise TypeError(
+ "Duplicated instrumented properties: %s.\n%s"
+ % (duplicates, self.interface.location)
+ )
+
+ if self.concrete:
+ self.proxy = False
+ iface = self.interface
+ for m in iface.members:
+ # Don't worry about inheriting legacycallers either: in
+ # practice these are on most-derived prototypes.
+ if m.isMethod() and m.isLegacycaller():
+ if not m.isIdentifierLess():
+ raise TypeError(
+ "We don't support legacycaller with "
+ "identifier.\n%s" % m.location
+ )
+ if len(m.signatures()) != 1:
+ raise TypeError(
+ "We don't support overloaded "
+ "legacycaller.\n%s" % m.location
+ )
+ addOperation("LegacyCaller", m)
+
+ while iface:
+ for m in iface.members:
+ if not m.isMethod():
+ continue
+
+ def addIndexedOrNamedOperation(operation, m):
+ if m.isIndexed():
+ operation = "Indexed" + operation
+ else:
+ assert m.isNamed()
+ operation = "Named" + operation
+ addOperation(operation, m)
+
+ if m.isGetter():
+ addIndexedOrNamedOperation("Getter", m)
+ if m.isSetter():
+ addIndexedOrNamedOperation("Setter", m)
+ if m.isDeleter():
+ addIndexedOrNamedOperation("Deleter", m)
+ if m.isLegacycaller() and iface != self.interface:
+ raise TypeError(
+ "We don't support legacycaller on "
+ "non-leaf interface %s.\n%s" % (iface, iface.location)
+ )
+
+ iface.setUserData("hasConcreteDescendant", True)
+ iface = iface.parent
+
+ self.proxy = (
+ self.supportsIndexedProperties()
+ or (
+ self.supportsNamedProperties() and not self.hasNamedPropertiesObject
+ )
+ or self.isMaybeCrossOriginObject()
+ )
+
+ if self.proxy:
+ if self.isMaybeCrossOriginObject() and (
+ self.supportsIndexedProperties() or self.supportsNamedProperties()
+ ):
+ raise TypeError(
+ "We don't support named or indexed "
+ "properties on maybe-cross-origin objects. "
+ "This lets us assume that their proxy "
+ "hooks are never called via Xrays. "
+ "Fix %s.\n%s" % (self.interface, self.interface.location)
+ )
+
+ if not self.operations["IndexedGetter"] and (
+ self.operations["IndexedSetter"]
+ or self.operations["IndexedDeleter"]
+ ):
+ raise SyntaxError(
+ "%s supports indexed properties but does "
+ "not have an indexed getter.\n%s"
+ % (self.interface, self.interface.location)
+ )
+ if not self.operations["NamedGetter"] and (
+ self.operations["NamedSetter"] or self.operations["NamedDeleter"]
+ ):
+ raise SyntaxError(
+ "%s supports named properties but does "
+ "not have a named getter.\n%s"
+ % (self.interface, self.interface.location)
+ )
+ iface = self.interface
+ while iface:
+ iface.setUserData("hasProxyDescendant", True)
+ iface = iface.parent
+
+ if desc.get("wantsQI", None) is not None:
+ self._wantsQI = desc.get("wantsQI", None)
+ self.wrapperCache = (
+ not self.interface.isCallback()
+ and not self.interface.isIteratorInterface()
+ and not self.interface.isAsyncIteratorInterface()
+ and desc.get("wrapperCache", True)
+ )
+
+ self.name = interface.identifier.name
+
+ # self.implicitJSContext is a list of names of methods and attributes
+ # that need a JSContext.
+ if self.interface.isJSImplemented():
+ self.implicitJSContext = ["constructor"]
+ else:
+ self.implicitJSContext = desc.get("implicitJSContext", [])
+ assert isinstance(self.implicitJSContext, list)
+
+ self._binaryNames = {}
+
+ if not self.interface.isExternal():
+
+ def maybeAddBinaryName(member):
+ binaryName = member.getExtendedAttribute("BinaryName")
+ if binaryName:
+ assert isinstance(binaryName, list)
+ assert len(binaryName) == 1
+ self._binaryNames.setdefault(
+ (member.identifier.name, member.isStatic()), binaryName[0]
+ )
+
+ for member in self.interface.members:
+ if not member.isAttr() and not member.isMethod():
+ continue
+ maybeAddBinaryName(member)
+
+ ctor = self.interface.ctor()
+ if ctor:
+ maybeAddBinaryName(ctor)
+
+ # Some default binary names for cases when nothing else got set.
+ self._binaryNames.setdefault(("__legacycaller", False), "LegacyCall")
+ self._binaryNames.setdefault(("__stringifier", False), "Stringify")
+
+ # Build the prototype chain.
+ self.prototypeChain = []
+ self.needsMissingPropUseCounters = False
+ parent = interface
+ while parent:
+ self.needsMissingPropUseCounters = (
+ self.needsMissingPropUseCounters
+ or parent.getExtendedAttribute("InstrumentedProps")
+ )
+ self.prototypeChain.insert(0, parent.identifier.name)
+ parent = parent.parent
+ config.maxProtoChainLength = max(
+ config.maxProtoChainLength, len(self.prototypeChain)
+ )
+
+ self.hasOrdinaryObjectPrototype = desc.get("hasOrdinaryObjectPrototype", False)
+
+ def binaryNameFor(self, name, isStatic):
+ return self._binaryNames.get((name, isStatic), name)
+
+ @property
+ def prototypeNameChain(self):
+ return [self.getDescriptor(p).name for p in self.prototypeChain]
+
+ @property
+ def parentPrototypeName(self):
+ if len(self.prototypeChain) == 1:
+ return None
+ return self.getDescriptor(self.prototypeChain[-2]).name
+
+ def hasInterfaceOrInterfacePrototypeObject(self):
+ return (
+ self.interface.hasInterfaceObject()
+ or self.interface.hasInterfacePrototypeObject()
+ )
+
+ @property
+ def hasNamedPropertiesObject(self):
+ return self.isGlobal() and self.supportsNamedProperties()
+
+ def getExtendedAttributes(self, member, getter=False, setter=False):
+ def ensureValidBoolExtendedAttribute(attr, name):
+ if attr is not None and attr is not True:
+ raise TypeError("Unknown value for '%s': %s" % (name, attr[0]))
+
+ def ensureValidThrowsExtendedAttribute(attr):
+ ensureValidBoolExtendedAttribute(attr, "Throws")
+
+ def ensureValidCanOOMExtendedAttribute(attr):
+ ensureValidBoolExtendedAttribute(attr, "CanOOM")
+
+ def maybeAppendNeedsErrorResultToAttrs(attrs, throws):
+ ensureValidThrowsExtendedAttribute(throws)
+ if throws is not None:
+ attrs.append("needsErrorResult")
+
+ def maybeAppendCanOOMToAttrs(attrs, canOOM):
+ ensureValidCanOOMExtendedAttribute(canOOM)
+ if canOOM is not None:
+ attrs.append("canOOM")
+
+ def maybeAppendNeedsSubjectPrincipalToAttrs(attrs, needsSubjectPrincipal):
+ if (
+ needsSubjectPrincipal is not None
+ and needsSubjectPrincipal is not True
+ and needsSubjectPrincipal != ["NonSystem"]
+ ):
+ raise TypeError(
+ "Unknown value for 'NeedsSubjectPrincipal': %s"
+ % needsSubjectPrincipal[0]
+ )
+
+ if needsSubjectPrincipal is not None:
+ attrs.append("needsSubjectPrincipal")
+ if needsSubjectPrincipal == ["NonSystem"]:
+ attrs.append("needsNonSystemSubjectPrincipal")
+
+ name = member.identifier.name
+ throws = self.interface.isJSImplemented() or member.getExtendedAttribute(
+ "Throws"
+ )
+ canOOM = member.getExtendedAttribute("CanOOM")
+ needsSubjectPrincipal = member.getExtendedAttribute("NeedsSubjectPrincipal")
+ attrs = []
+ if name in self.implicitJSContext:
+ attrs.append("implicitJSContext")
+ if member.isMethod():
+ if self.interface.isAsyncIteratorInterface() and name == "next":
+ attrs.append("implicitJSContext")
+ # JSObject-returning [NewObject] methods must be fallible,
+ # since they have to (fallibly) allocate the new JSObject.
+ if member.getExtendedAttribute("NewObject"):
+ if member.returnsPromise():
+ throws = True
+ elif methodReturnsJSObject(member):
+ canOOM = True
+ maybeAppendNeedsErrorResultToAttrs(attrs, throws)
+ maybeAppendCanOOMToAttrs(attrs, canOOM)
+ maybeAppendNeedsSubjectPrincipalToAttrs(attrs, needsSubjectPrincipal)
+ return attrs
+
+ assert member.isAttr()
+ assert bool(getter) != bool(setter)
+ if throws is None:
+ throwsAttr = "GetterThrows" if getter else "SetterThrows"
+ throws = member.getExtendedAttribute(throwsAttr)
+ maybeAppendNeedsErrorResultToAttrs(attrs, throws)
+ if canOOM is None:
+ canOOMAttr = "GetterCanOOM" if getter else "SetterCanOOM"
+ canOOM = member.getExtendedAttribute(canOOMAttr)
+ maybeAppendCanOOMToAttrs(attrs, canOOM)
+ if needsSubjectPrincipal is None:
+ needsSubjectPrincipalAttr = (
+ "GetterNeedsSubjectPrincipal"
+ if getter
+ else "SetterNeedsSubjectPrincipal"
+ )
+ needsSubjectPrincipal = member.getExtendedAttribute(
+ needsSubjectPrincipalAttr
+ )
+ maybeAppendNeedsSubjectPrincipalToAttrs(attrs, needsSubjectPrincipal)
+ return attrs
+
+ def supportsIndexedProperties(self):
+ return self.operations["IndexedGetter"] is not None
+
+ def lengthNeedsCallerType(self):
+ """
+ Determine whether our length getter needs a caller type; this is needed
+ in some indexed-getter proxy algorithms. The idea is that if our
+ indexed getter needs a caller type, our automatically-generated Length()
+ calls need one too.
+ """
+ assert self.supportsIndexedProperties()
+ indexedGetter = self.operations["IndexedGetter"]
+ return indexedGetter.getExtendedAttribute("NeedsCallerType")
+
+ def supportsNamedProperties(self):
+ return self.operations["NamedGetter"] is not None
+
+ def supportedNamesNeedCallerType(self):
+ """
+ Determine whether our GetSupportedNames call needs a caller type. The
+ idea is that if your named getter needs a caller type, then so does
+ GetSupportedNames.
+ """
+ assert self.supportsNamedProperties()
+ namedGetter = self.operations["NamedGetter"]
+ return namedGetter.getExtendedAttribute("NeedsCallerType")
+
+ def isMaybeCrossOriginObject(self):
+ # If we're isGlobal and have cross-origin members, we're a Window, and
+ # that's not a cross-origin object. The WindowProxy is.
+ return (
+ self.concrete
+ and self.interface.hasCrossOriginMembers
+ and not self.isGlobal()
+ )
+
+ def needsHeaderInclude(self):
+ """
+ An interface doesn't need a header file if it is not concrete, not
+ pref-controlled, has no prototype object, has no static methods or
+ attributes and has no parent. The parent matters because we assert
+ things about refcounting that depend on the actual underlying type if we
+ have a parent.
+
+ """
+ return (
+ self.interface.isExternal()
+ or self.concrete
+ or self.interface.hasInterfacePrototypeObject()
+ or any(
+ (m.isAttr() or m.isMethod()) and m.isStatic()
+ for m in self.interface.members
+ )
+ or self.interface.parent
+ )
+
+ def hasThreadChecks(self):
+ # isExposedConditionally does not necessarily imply thread checks
+ # (since at least [SecureContext] is independent of them), but we're
+ # only used to decide whether to include nsThreadUtils.h, so we don't
+ # worry about that.
+ return (
+ self.isExposedConditionally() and not self.interface.isExposedInWindow()
+ ) or self.interface.isExposedInSomeButNotAllWorkers()
+
+ def hasCEReactions(self):
+ return any(
+ m.getExtendedAttribute("CEReactions") for m in self.interface.members
+ )
+
+ def isExposedConditionally(self):
+ return (
+ self.interface.isExposedConditionally()
+ or self.interface.isExposedInSomeButNotAllWorkers()
+ )
+
+ def needsXrayResolveHooks(self):
+ """
+ Generally, any interface with NeedResolve needs Xray
+ resolveOwnProperty and enumerateOwnProperties hooks. But for
+ the special case of plugin-loading elements, we do NOT want
+ those, because we don't want to instantiate plug-ins simply
+ due to chrome touching them and that's all those hooks do on
+ those elements. So we special-case those here.
+ """
+ return self.interface.getExtendedAttribute(
+ "NeedResolve"
+ ) and self.interface.identifier.name not in [
+ "HTMLObjectElement",
+ "HTMLEmbedElement",
+ ]
+
+ def needsXrayNamedDeleterHook(self):
+ return self.operations["NamedDeleter"] is not None
+
+ def isGlobal(self):
+ """
+ Returns true if this is the primary interface for a global object
+ of some sort.
+ """
+ return self.interface.getExtendedAttribute("Global")
+
+ @property
+ def namedPropertiesEnumerable(self):
+ """
+ Returns whether this interface should have enumerable named properties
+ """
+ assert self.proxy
+ assert self.supportsNamedProperties()
+ iface = self.interface
+ while iface:
+ if iface.getExtendedAttribute("LegacyUnenumerableNamedProperties"):
+ return False
+ iface = iface.parent
+ return True
+
+ @property
+ def registersGlobalNamesOnWindow(self):
+ return (
+ self.interface.hasInterfaceObject()
+ and self.interface.isExposedInWindow()
+ and self.register
+ )
+
+ def getDescriptor(self, interfaceName):
+ """
+ Gets the appropriate descriptor for the given interface name.
+ """
+ return self.config.getDescriptor(interfaceName)
+
+ def getConfig(self):
+ return self.config
+
+
+# Some utility methods
+def getTypesFromDescriptor(descriptor, includeArgs=True, includeReturns=True):
+ """
+ Get argument and/or return types for all members of the descriptor. By
+ default returns all argument types (which includes types of writable
+ attributes) and all return types (which includes types of all attributes).
+ """
+ assert includeArgs or includeReturns # Must want _something_.
+ members = [m for m in descriptor.interface.members]
+ if descriptor.interface.ctor():
+ members.append(descriptor.interface.ctor())
+ members.extend(descriptor.interface.legacyFactoryFunctions)
+ signatures = [s for m in members if m.isMethod() for s in m.signatures()]
+ types = []
+ for s in signatures:
+ assert len(s) == 2
+ (returnType, arguments) = s
+ if includeReturns:
+ types.append(returnType)
+ if includeArgs:
+ types.extend(a.type for a in arguments)
+
+ types.extend(
+ a.type
+ for a in members
+ if (a.isAttr() and (includeReturns or (includeArgs and not a.readonly)))
+ )
+
+ if descriptor.interface.maplikeOrSetlikeOrIterable:
+ maplikeOrSetlikeOrIterable = descriptor.interface.maplikeOrSetlikeOrIterable
+ if maplikeOrSetlikeOrIterable.isMaplike():
+ # The things we expand into may or may not correctly indicate in
+ # their formal IDL types what things we have as return values. For
+ # example, "keys" returns the moral equivalent of sequence<keyType>
+ # but just claims to return "object". Similarly, "values" returns
+ # the moral equivalent of sequence<valueType> but claims to return
+ # "object". And due to bug 1155340, "get" claims to return "any"
+ # instead of the right type. So let's just manually work around
+ # that lack of specificity. For our arguments, we already enforce
+ # the right types at the IDL level, so those will get picked up
+ # correctly.
+ assert maplikeOrSetlikeOrIterable.hasKeyType()
+ assert maplikeOrSetlikeOrIterable.hasValueType()
+ if includeReturns:
+ types.append(maplikeOrSetlikeOrIterable.keyType)
+ types.append(maplikeOrSetlikeOrIterable.valueType)
+ elif maplikeOrSetlikeOrIterable.isSetlike():
+ assert maplikeOrSetlikeOrIterable.hasKeyType()
+ assert maplikeOrSetlikeOrIterable.hasValueType()
+ assert (
+ maplikeOrSetlikeOrIterable.keyType
+ == maplikeOrSetlikeOrIterable.valueType
+ )
+ # As in the maplike case, we don't always declare our return values
+ # quite correctly.
+ if includeReturns:
+ types.append(maplikeOrSetlikeOrIterable.keyType)
+ else:
+ assert (
+ maplikeOrSetlikeOrIterable.isIterable()
+ or maplikeOrSetlikeOrIterable.isAsyncIterable()
+ )
+ # As in the maplike/setlike cases we don't do a good job of
+ # declaring our actual return types, while our argument types, if
+ # any, are declared fine.
+ if includeReturns:
+ if maplikeOrSetlikeOrIterable.hasKeyType():
+ types.append(maplikeOrSetlikeOrIterable.keyType)
+ if maplikeOrSetlikeOrIterable.hasValueType():
+ types.append(maplikeOrSetlikeOrIterable.valueType)
+
+ return types
+
+
+def getTypesFromDictionary(dictionary):
+ """
+ Get all member types for this dictionary
+ """
+ return [m.type for m in dictionary.members]
+
+
+def getTypesFromCallback(callback):
+ """
+ Get the types this callback depends on: its return type and the
+ types of its arguments.
+ """
+ sig = callback.signatures()[0]
+ types = [sig[0]] # Return type
+ types.extend(arg.type for arg in sig[1]) # Arguments
+ return types
+
+
+def getAllTypes(descriptors, dictionaries, callbacks):
+ """
+ Generate all the types we're dealing with. For each type, a tuple
+ containing type, dictionary is yielded. The dictionary can be None if the
+ type does not come from a dictionary.
+ """
+ for d in descriptors:
+ if d.interface.isExternal():
+ continue
+ for t in getTypesFromDescriptor(d):
+ yield (t, None)
+ for dictionary in dictionaries:
+ for t in getTypesFromDictionary(dictionary):
+ yield (t, dictionary)
+ for callback in callbacks:
+ for t in getTypesFromCallback(callback):
+ yield (t, callback)
+
+
+# For sync value iterators, we use default array implementation, for async
+# iterators and sync pair iterators, we use AsyncIterableIterator or
+# IterableIterator instead.
+def iteratorNativeType(descriptor):
+ assert descriptor.interface.isIterable() or descriptor.interface.isAsyncIterable()
+ iterableDecl = descriptor.interface.maplikeOrSetlikeOrIterable
+ assert iterableDecl.isPairIterator() or descriptor.interface.isAsyncIterable()
+ if descriptor.interface.isIterable():
+ return "mozilla::dom::IterableIterator<%s>" % descriptor.nativeType
+ needReturnMethod = toStringBool(
+ descriptor.interface.maplikeOrSetlikeOrIterable.getExtendedAttribute(
+ "GenerateReturnMethod"
+ )
+ is not None
+ )
+ return "mozilla::dom::binding_detail::AsyncIterableIteratorNative<%s, %s>" % (
+ descriptor.nativeType,
+ needReturnMethod,
+ )
+
+
+def findInnermostType(t):
+ """
+ Find the innermost type of the given type, unwrapping Promise and Record
+ types, as well as everything that unroll() unwraps.
+ """
+ while True:
+ if t.isRecord():
+ t = t.inner
+ elif t.unroll() != t:
+ t = t.unroll()
+ elif t.isPromise():
+ t = t.promiseInnerType()
+ else:
+ return t
+
+
+def getDependentDictionariesFromDictionary(d):
+ """
+ Find all the dictionaries contained in the given dictionary, as ancestors or
+ members. This returns a generator.
+ """
+ while d:
+ yield d
+ for member in d.members:
+ for next in getDictionariesFromType(member.type):
+ yield next
+ d = d.parent
+
+
+def getDictionariesFromType(type):
+ """
+ Find all the dictionaries contained in type. This can be used to find
+ dictionaries that need conversion to JS (by looking at types that get
+ converted to JS) or dictionaries that need conversion from JS (by looking at
+ types that get converted from JS).
+
+ This returns a generator.
+ """
+ type = findInnermostType(type)
+ if type.isUnion():
+ # Look for dictionaries in all the member types
+ for t in type.flatMemberTypes:
+ for next in getDictionariesFromType(t):
+ yield next
+ elif type.isDictionary():
+ # Find the dictionaries that are itself, any of its ancestors, or
+ # contained in any of its member types.
+ for d in getDependentDictionariesFromDictionary(type.inner):
+ yield d
+
+
+def getDictionariesConvertedToJS(descriptors, dictionaries, callbacks):
+ for desc in descriptors:
+ if desc.interface.isExternal():
+ continue
+
+ if desc.interface.isJSImplemented():
+ # For a JS-implemented interface, we need to-JS
+ # conversions for all the types involved.
+ for t in getTypesFromDescriptor(desc):
+ for d in getDictionariesFromType(t):
+ yield d
+ elif desc.interface.isCallback():
+ # For callbacks we only want to include the arguments, since that's
+ # where the to-JS conversion happens.
+ for t in getTypesFromDescriptor(desc, includeReturns=False):
+ for d in getDictionariesFromType(t):
+ yield d
+ else:
+ # For normal interfaces, we only want to include return values,
+ # since that's where to-JS conversion happens.
+ for t in getTypesFromDescriptor(desc, includeArgs=False):
+ for d in getDictionariesFromType(t):
+ yield d
+
+ for callback in callbacks:
+ # We only want to look at the arguments
+ sig = callback.signatures()[0]
+ for arg in sig[1]:
+ for d in getDictionariesFromType(arg.type):
+ yield d
+
+ for dictionary in dictionaries:
+ if dictionary.needsConversionToJS:
+ # It's explicitly flagged as needing to-JS conversion, and all its
+ # dependent dictionaries will need to-JS conversion too.
+ for d in getDependentDictionariesFromDictionary(dictionary):
+ yield d
+
+
+def getDictionariesConvertedFromJS(descriptors, dictionaries, callbacks):
+ for desc in descriptors:
+ if desc.interface.isExternal():
+ continue
+
+ if desc.interface.isJSImplemented():
+ # For a JS-implemented interface, we need from-JS conversions for
+ # all the types involved.
+ for t in getTypesFromDescriptor(desc):
+ for d in getDictionariesFromType(t):
+ yield d
+ elif desc.interface.isCallback():
+ # For callbacks we only want to include the return value, since
+ # that's where teh from-JS conversion happens.
+ for t in getTypesFromDescriptor(desc, includeArgs=False):
+ for d in getDictionariesFromType(t):
+ yield d
+ else:
+ # For normal interfaces, we only want to include arguments values,
+ # since that's where from-JS conversion happens.
+ for t in getTypesFromDescriptor(desc, includeReturns=False):
+ for d in getDictionariesFromType(t):
+ yield d
+
+ for callback in callbacks:
+ # We only want to look at the return value
+ sig = callback.signatures()[0]
+ for d in getDictionariesFromType(sig[0]):
+ yield d
+
+ for dictionary in dictionaries:
+ if dictionary.needsConversionFromJS:
+ # It's explicitly flagged as needing from-JS conversion, and all its
+ # dependent dictionaries will need from-JS conversion too.
+ for d in getDependentDictionariesFromDictionary(dictionary):
+ yield d