summaryrefslogtreecommitdiffstats
path: root/dom/bindings/Codegen.py
diff options
context:
space:
mode:
Diffstat (limited to 'dom/bindings/Codegen.py')
-rw-r--r--dom/bindings/Codegen.py17364
1 files changed, 17364 insertions, 0 deletions
diff --git a/dom/bindings/Codegen.py b/dom/bindings/Codegen.py
new file mode 100644
index 000000000..3174c37dd
--- /dev/null
+++ b/dom/bindings/Codegen.py
@@ -0,0 +1,17364 @@
+# 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/.
+
+# Common codegen classes.
+
+import os
+import re
+import string
+import math
+import textwrap
+import functools
+
+from WebIDL import BuiltinTypes, IDLBuiltinType, IDLNullValue, IDLSequenceType, IDLType, IDLAttribute, IDLInterfaceMember, IDLUndefinedValue, IDLEmptySequenceValue, IDLDictionary
+from Configuration import NoSuchDescriptorError, getTypesFromDescriptor, getTypesFromDictionary, getTypesFromCallback, getAllTypes, Descriptor, MemberIsUnforgeable, iteratorNativeType
+
+AUTOGENERATED_WARNING_COMMENT = \
+ "/* THIS FILE IS AUTOGENERATED BY Codegen.py - DO NOT EDIT */\n\n"
+AUTOGENERATED_WITH_SOURCE_WARNING_COMMENT = \
+ "/* THIS FILE IS AUTOGENERATED FROM %s BY Codegen.py - DO NOT EDIT */\n\n"
+ADDPROPERTY_HOOK_NAME = '_addProperty'
+FINALIZE_HOOK_NAME = '_finalize'
+OBJECT_MOVED_HOOK_NAME = '_objectMoved'
+CONSTRUCT_HOOK_NAME = '_constructor'
+LEGACYCALLER_HOOK_NAME = '_legacycaller'
+HASINSTANCE_HOOK_NAME = '_hasInstance'
+RESOLVE_HOOK_NAME = '_resolve'
+MAY_RESOLVE_HOOK_NAME = '_mayResolve'
+ENUMERATE_HOOK_NAME = '_enumerate'
+ENUM_ENTRY_VARIABLE_NAME = 'strings'
+INSTANCE_RESERVED_SLOTS = 1
+
+
+def memberReservedSlot(member, descriptor):
+ return ("(DOM_INSTANCE_RESERVED_SLOTS + %d)" %
+ member.slotIndices[descriptor.interface.identifier.name])
+
+
+def memberXrayExpandoReservedSlot(member, descriptor):
+ return ("(xpc::JSSLOT_EXPANDO_COUNT + %d)" %
+ member.slotIndices[descriptor.interface.identifier.name])
+
+
+def mayUseXrayExpandoSlots(descriptor, attr):
+ assert not attr.getExtendedAttribute("NewObject")
+ # For attributes whose type is a Gecko interface we always use
+ # slots on the reflector for caching. Also, for interfaces that
+ # don't want Xrays we obviously never use the Xray expando slot.
+ return descriptor.wantsXrays and not attr.type.isGeckoInterface()
+
+
+def toStringBool(arg):
+ return str(not not arg).lower()
+
+
+def toBindingNamespace(arg):
+ return arg + "Binding"
+
+
+def isTypeCopyConstructible(type):
+ # Nullable and sequence stuff doesn't affect copy-constructibility
+ type = type.unroll()
+ return (type.isPrimitive() or type.isString() or type.isEnum() or
+ (type.isUnion() and
+ CGUnionStruct.isUnionCopyConstructible(type)) or
+ (type.isDictionary() and
+ CGDictionary.isDictionaryCopyConstructible(type.inner)) or
+ # Interface types are only copy-constructible if they're Gecko
+ # interfaces. SpiderMonkey interfaces are not copy-constructible
+ # because of rooting issues.
+ (type.isInterface() and type.isGeckoInterface()))
+
+
+def idlTypeNeedsCycleCollection(type):
+ type = type.unroll() # Takes care of sequences and nullables
+ if ((type.isPrimitive() and type.tag() in builtinNames) or
+ type.isEnum() or
+ type.isString() or
+ type.isAny() or
+ type.isObject() or
+ type.isSpiderMonkeyInterface()):
+ return False
+ elif type.isCallback() or type.isGeckoInterface():
+ return True
+ elif type.isUnion():
+ return any(idlTypeNeedsCycleCollection(t) for t in type.flatMemberTypes)
+ elif type.isMozMap():
+ if idlTypeNeedsCycleCollection(type.inner):
+ raise TypeError("Cycle collection for type %s is not supported" % type)
+ return False
+ elif type.isDictionary():
+ if any(idlTypeNeedsCycleCollection(m.type) for m in type.inner.members):
+ raise TypeError("Cycle collection for type %s is not supported" % type)
+ return False
+ else:
+ raise TypeError("Don't know whether to cycle-collect type %s" % type)
+
+
+def wantsAddProperty(desc):
+ return (desc.concrete and desc.wrapperCache and not desc.isGlobal())
+
+
+# We'll want to insert the indent at the beginnings of lines, but we
+# don't want to indent empty lines. So only indent lines that have a
+# non-newline character on them.
+lineStartDetector = re.compile("^(?=[^\n#])", re.MULTILINE)
+
+
+def indent(s, indentLevel=2):
+ """
+ Indent C++ code.
+
+ Weird secret feature: this doesn't indent lines that start with # (such as
+ #include lines or #ifdef/#endif).
+ """
+ if s == "":
+ return s
+ return re.sub(lineStartDetector, indentLevel * " ", s)
+
+
+# dedent() and fill() are often called on the same string multiple
+# times. We want to memoize their return values so we don't keep
+# recomputing them all the time.
+def memoize(fn):
+ """
+ Decorator to memoize a function of one argument. The cache just
+ grows without bound.
+ """
+ cache = {}
+
+ @functools.wraps(fn)
+ def wrapper(arg):
+ retval = cache.get(arg)
+ if retval is None:
+ retval = cache[arg] = fn(arg)
+ return retval
+ return wrapper
+
+
+@memoize
+def dedent(s):
+ """
+ Remove all leading whitespace from s, and remove a blank line
+ at the beginning.
+ """
+ if s.startswith('\n'):
+ s = s[1:]
+ return textwrap.dedent(s)
+
+
+# This works by transforming the fill()-template to an equivalent
+# string.Template.
+fill_multiline_substitution_re = re.compile(r"( *)\$\*{(\w+)}(\n)?")
+
+
+find_substitutions = re.compile(r"\${")
+
+
+@memoize
+def compile_fill_template(template):
+ """
+ Helper function for fill(). Given the template string passed to fill(),
+ do the reusable part of template processing and return a pair (t,
+ argModList) that can be used every time fill() is called with that
+ template argument.
+
+ argsModList is list of tuples that represent modifications to be
+ made to args. Each modification has, in order: i) the arg name,
+ ii) the modified name, iii) the indent depth.
+ """
+ t = dedent(template)
+ assert t.endswith("\n") or "\n" not in t
+ argModList = []
+
+ def replace(match):
+ """
+ Replaces a line like ' $*{xyz}\n' with '${xyz_n}',
+ where n is the indent depth, and add a corresponding entry to
+ argModList.
+
+ Note that this needs to close over argModList, so it has to be
+ defined inside compile_fill_template().
+ """
+ indentation, name, nl = match.groups()
+ depth = len(indentation)
+
+ # Check that $*{xyz} appears by itself on a line.
+ prev = match.string[:match.start()]
+ if (prev and not prev.endswith("\n")) or nl is None:
+ raise ValueError("Invalid fill() template: $*{%s} must appear by itself on a line" % name)
+
+ # Now replace this whole line of template with the indented equivalent.
+ modified_name = name + "_" + str(depth)
+ argModList.append((name, modified_name, depth))
+ return "${" + modified_name + "}"
+
+ t = re.sub(fill_multiline_substitution_re, replace, t)
+ if not re.search(find_substitutions, t):
+ raise TypeError("Using fill() when dedent() would do.")
+ return (string.Template(t), argModList)
+
+
+def fill(template, **args):
+ """
+ Convenience function for filling in a multiline template.
+
+ `fill(template, name1=v1, name2=v2)` is a lot like
+ `string.Template(template).substitute({"name1": v1, "name2": v2})`.
+
+ However, it's shorter, and has a few nice features:
+
+ * If `template` is indented, fill() automatically dedents it!
+ This makes code using fill() with Python's multiline strings
+ much nicer to look at.
+
+ * If `template` starts with a blank line, fill() strips it off.
+ (Again, convenient with multiline strings.)
+
+ * fill() recognizes a special kind of substitution
+ of the form `$*{name}`.
+
+ Use this to paste in, and automatically indent, multiple lines.
+ (Mnemonic: The `*` is for "multiple lines").
+
+ A `$*` substitution must appear by itself on a line, with optional
+ preceding indentation (spaces only). The whole line is replaced by the
+ corresponding keyword argument, indented appropriately. If the
+ argument is an empty string, no output is generated, not even a blank
+ line.
+ """
+
+ t, argModList = compile_fill_template(template)
+ # Now apply argModList to args
+ for (name, modified_name, depth) in argModList:
+ if not (args[name] == "" or args[name].endswith("\n")):
+ raise ValueError("Argument %s with value %r is missing a newline" % (name, args[name]))
+ args[modified_name] = indent(args[name], depth)
+
+ return t.substitute(args)
+
+
+class CGThing():
+ """
+ Abstract base class for things that spit out code.
+ """
+ def __init__(self):
+ pass # Nothing for now
+
+ def declare(self):
+ """Produce code for a header file."""
+ assert False # Override me!
+
+ def define(self):
+ """Produce code for a cpp file."""
+ assert False # Override me!
+
+ def deps(self):
+ """Produce the deps for a pp file"""
+ assert False # Override me!
+
+
+class CGStringTable(CGThing):
+ """
+ Generate a string table for the given strings with a function accessor:
+
+ const char *accessorName(unsigned int index) {
+ static const char table[] = "...";
+ static const uint16_t indices = { ... };
+ return &table[indices[index]];
+ }
+
+ This is more efficient than the more natural:
+
+ const char *table[] = {
+ ...
+ };
+
+ The uint16_t indices are smaller than the pointer equivalents, and the
+ string table requires no runtime relocations.
+ """
+ def __init__(self, accessorName, strings):
+ CGThing.__init__(self)
+ self.accessorName = accessorName
+ self.strings = strings
+
+ def declare(self):
+ return "extern const char *%s(unsigned int aIndex);\n" % self.accessorName
+
+ def define(self):
+ table = ' "\\0" '.join('"%s"' % s for s in self.strings)
+ indices = []
+ currentIndex = 0
+ for s in self.strings:
+ indices.append(currentIndex)
+ currentIndex += len(s) + 1 # for the null terminator
+ return fill(
+ """
+ const char *${name}(unsigned int aIndex)
+ {
+ static const char table[] = ${table};
+ static const uint16_t indices[] = { ${indices} };
+ static_assert(${currentIndex} <= UINT16_MAX, "string table overflow!");
+ return &table[indices[aIndex]];
+ }
+ """,
+ name=self.accessorName,
+ table=table,
+ indices=", ".join("%d" % index for index in indices),
+ currentIndex=currentIndex)
+
+
+class CGNativePropertyHooks(CGThing):
+ """
+ Generate a NativePropertyHooks for a given descriptor
+ """
+ def __init__(self, descriptor, properties):
+ CGThing.__init__(self)
+ self.descriptor = descriptor
+ self.properties = properties
+
+ def declare(self):
+ if not self.descriptor.wantsXrays:
+ return ""
+ return dedent("""
+ // We declare this as an array so that retrieving a pointer to this
+ // binding's property hooks only requires compile/link-time resolvable
+ // address arithmetic. Declaring it as a pointer instead would require
+ // doing a run-time load to fetch a pointer to this binding's property
+ // hooks. And then structures which embedded a pointer to this structure
+ // would require a run-time load for proper initialization, which would
+ // then induce static constructors. Lots of static constructors.
+ extern const NativePropertyHooks sNativePropertyHooks[];
+ """)
+
+ def define(self):
+ if not self.descriptor.wantsXrays:
+ return ""
+ deleteNamedProperty = "nullptr"
+ if self.descriptor.concrete and self.descriptor.proxy:
+ resolveOwnProperty = "ResolveOwnProperty"
+ enumerateOwnProperties = "EnumerateOwnProperties"
+ if self.descriptor.needsXrayNamedDeleterHook():
+ deleteNamedProperty = "DeleteNamedProperty"
+ elif self.descriptor.needsXrayResolveHooks():
+ resolveOwnProperty = "ResolveOwnPropertyViaResolve"
+ enumerateOwnProperties = "EnumerateOwnPropertiesViaGetOwnPropertyNames"
+ else:
+ resolveOwnProperty = "nullptr"
+ enumerateOwnProperties = "nullptr"
+ if self.properties.hasNonChromeOnly():
+ regular = "sNativeProperties.Upcast()"
+ else:
+ regular = "nullptr"
+ if self.properties.hasChromeOnly():
+ chrome = "sChromeOnlyNativeProperties.Upcast()"
+ else:
+ chrome = "nullptr"
+ constructorID = "constructors::id::"
+ if self.descriptor.interface.hasInterfaceObject():
+ constructorID += self.descriptor.name
+ else:
+ constructorID += "_ID_Count"
+ prototypeID = "prototypes::id::"
+ if self.descriptor.interface.hasInterfacePrototypeObject():
+ prototypeID += self.descriptor.name
+ else:
+ prototypeID += "_ID_Count"
+ parentProtoName = self.descriptor.parentPrototypeName
+ parentHooks = (toBindingNamespace(parentProtoName) + "::sNativePropertyHooks"
+ if parentProtoName else 'nullptr')
+
+ if self.descriptor.wantsXrayExpandoClass:
+ expandoClass = "&sXrayExpandoObjectClass"
+ else:
+ expandoClass = "&DefaultXrayExpandoObjectClass"
+
+ return fill(
+ """
+ const NativePropertyHooks sNativePropertyHooks[] = { {
+ ${resolveOwnProperty},
+ ${enumerateOwnProperties},
+ ${deleteNamedProperty},
+ { ${regular}, ${chrome} },
+ ${prototypeID},
+ ${constructorID},
+ ${parentHooks},
+ ${expandoClass}
+ } };
+ """,
+ resolveOwnProperty=resolveOwnProperty,
+ enumerateOwnProperties=enumerateOwnProperties,
+ deleteNamedProperty=deleteNamedProperty,
+ regular=regular,
+ chrome=chrome,
+ prototypeID=prototypeID,
+ constructorID=constructorID,
+ parentHooks=parentHooks,
+ expandoClass=expandoClass)
+
+
+def NativePropertyHooks(descriptor):
+ return "&sEmptyNativePropertyHooks" if not descriptor.wantsXrays else "sNativePropertyHooks"
+
+
+def DOMClass(descriptor):
+ protoList = ['prototypes::id::' + proto for proto in descriptor.prototypeNameChain]
+ # Pad out the list to the right length with _ID_Count so we
+ # guarantee that all the lists are the same length. _ID_Count
+ # is never the ID of any prototype, so it's safe to use as
+ # padding.
+ protoList.extend(['prototypes::id::_ID_Count'] * (descriptor.config.maxProtoChainLength - len(protoList)))
+
+ return fill(
+ """
+ { ${protoChain} },
+ IsBaseOf<nsISupports, ${nativeType} >::value,
+ ${hooks},
+ FindAssociatedGlobalForNative<${nativeType}>::Get,
+ GetProtoObjectHandle,
+ GetCCParticipant<${nativeType}>::Get()
+ """,
+ protoChain=', '.join(protoList),
+ nativeType=descriptor.nativeType,
+ hooks=NativePropertyHooks(descriptor))
+
+
+class CGDOMJSClass(CGThing):
+ """
+ Generate a DOMJSClass for a given descriptor
+ """
+ def __init__(self, descriptor):
+ CGThing.__init__(self)
+ self.descriptor = descriptor
+
+ def declare(self):
+ return ""
+
+ def define(self):
+ callHook = LEGACYCALLER_HOOK_NAME if self.descriptor.operations["LegacyCaller"] else 'nullptr'
+ objectMovedHook = OBJECT_MOVED_HOOK_NAME if self.descriptor.wrapperCache else 'nullptr'
+ slotCount = INSTANCE_RESERVED_SLOTS + self.descriptor.interface.totalMembersInSlots
+ classFlags = "JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE | "
+ if self.descriptor.isGlobal():
+ classFlags += "JSCLASS_DOM_GLOBAL | JSCLASS_GLOBAL_FLAGS_WITH_SLOTS(DOM_GLOBAL_SLOTS)"
+ traceHook = "JS_GlobalObjectTraceHook"
+ reservedSlots = "JSCLASS_GLOBAL_APPLICATION_SLOTS"
+ else:
+ classFlags += "JSCLASS_HAS_RESERVED_SLOTS(%d)" % slotCount
+ traceHook = 'nullptr'
+ reservedSlots = slotCount
+ if self.descriptor.interface.isProbablyShortLivingObject():
+ classFlags += " | JSCLASS_SKIP_NURSERY_FINALIZE"
+ if self.descriptor.interface.getExtendedAttribute("NeedResolve"):
+ resolveHook = RESOLVE_HOOK_NAME
+ mayResolveHook = MAY_RESOLVE_HOOK_NAME
+ enumerateHook = ENUMERATE_HOOK_NAME
+ elif self.descriptor.isGlobal():
+ resolveHook = "mozilla::dom::ResolveGlobal"
+ mayResolveHook = "mozilla::dom::MayResolveGlobal"
+ enumerateHook = "mozilla::dom::EnumerateGlobal"
+ else:
+ resolveHook = "nullptr"
+ mayResolveHook = "nullptr"
+ enumerateHook = "nullptr"
+
+ return fill(
+ """
+ static const js::ClassOps sClassOps = {
+ ${addProperty}, /* addProperty */
+ nullptr, /* delProperty */
+ nullptr, /* getProperty */
+ nullptr, /* setProperty */
+ ${enumerate}, /* enumerate */
+ ${resolve}, /* resolve */
+ ${mayResolve}, /* mayResolve */
+ ${finalize}, /* finalize */
+ ${call}, /* call */
+ nullptr, /* hasInstance */
+ nullptr, /* construct */
+ ${trace}, /* trace */
+ };
+
+ static const js::ClassExtension sClassExtension = {
+ nullptr, /* weakmapKeyDelegateOp */
+ ${objectMoved} /* objectMovedOp */
+ };
+
+ static const DOMJSClass sClass = {
+ { "${name}",
+ ${flags},
+ &sClassOps,
+ JS_NULL_CLASS_SPEC,
+ &sClassExtension,
+ JS_NULL_OBJECT_OPS
+ },
+ $*{descriptor}
+ };
+ static_assert(${instanceReservedSlots} == DOM_INSTANCE_RESERVED_SLOTS,
+ "Must have the right minimal number of reserved slots.");
+ static_assert(${reservedSlots} >= ${slotCount},
+ "Must have enough reserved slots.");
+ """,
+ name=self.descriptor.interface.identifier.name,
+ flags=classFlags,
+ addProperty=ADDPROPERTY_HOOK_NAME if wantsAddProperty(self.descriptor) else 'nullptr',
+ enumerate=enumerateHook,
+ resolve=resolveHook,
+ mayResolve=mayResolveHook,
+ finalize=FINALIZE_HOOK_NAME,
+ call=callHook,
+ trace=traceHook,
+ objectMoved=objectMovedHook,
+ descriptor=DOMClass(self.descriptor),
+ instanceReservedSlots=INSTANCE_RESERVED_SLOTS,
+ reservedSlots=reservedSlots,
+ slotCount=slotCount)
+
+
+class CGDOMProxyJSClass(CGThing):
+ """
+ Generate a DOMJSClass for a given proxy descriptor
+ """
+ def __init__(self, descriptor):
+ CGThing.__init__(self)
+ self.descriptor = descriptor
+
+ def declare(self):
+ return ""
+
+ def define(self):
+ flags = ["JSCLASS_IS_DOMJSCLASS"]
+ # We don't use an IDL annotation for JSCLASS_EMULATES_UNDEFINED because
+ # we don't want people ever adding that to any interface other than
+ # HTMLAllCollection. So just hardcode it here.
+ if self.descriptor.interface.identifier.name == "HTMLAllCollection":
+ flags.append("JSCLASS_EMULATES_UNDEFINED")
+ objectMovedHook = OBJECT_MOVED_HOOK_NAME if self.descriptor.wrapperCache else 'nullptr'
+ return fill(
+ """
+ static const js::ClassExtension sClassExtension = PROXY_MAKE_EXT(
+ ${objectMoved}
+ );
+
+ static const DOMJSClass sClass = {
+ PROXY_CLASS_WITH_EXT("${name}",
+ ${flags},
+ &sClassExtension),
+ $*{descriptor}
+ };
+ """,
+ name=self.descriptor.interface.identifier.name,
+ flags=" | ".join(flags),
+ objectMoved=objectMovedHook,
+ descriptor=DOMClass(self.descriptor))
+
+
+class CGXrayExpandoJSClass(CGThing):
+ """
+ Generate a JSClass for an Xray expando object. This is only
+ needed if we have members in slots (for [Cached] or [StoreInSlot]
+ stuff).
+ """
+ def __init__(self, descriptor):
+ assert descriptor.interface.totalMembersInSlots != 0
+ assert descriptor.wantsXrays
+ assert descriptor.wantsXrayExpandoClass
+ CGThing.__init__(self)
+ self.descriptor = descriptor;
+
+ def declare(self):
+ return ""
+
+ def define(self):
+ return fill(
+ """
+ // This may allocate too many slots, because we only really need
+ // slots for our non-interface-typed members that we cache. But
+ // allocating slots only for those would make the slot index
+ // computations much more complicated, so let's do this the simple
+ // way for now.
+ DEFINE_XRAY_EXPANDO_CLASS(static, sXrayExpandoObjectClass, ${memberSlots});
+ """,
+ memberSlots=self.descriptor.interface.totalMembersInSlots)
+
+
+def PrototypeIDAndDepth(descriptor):
+ prototypeID = "prototypes::id::"
+ if descriptor.interface.hasInterfacePrototypeObject():
+ prototypeID += descriptor.interface.identifier.name
+ depth = "PrototypeTraits<%s>::Depth" % prototypeID
+ else:
+ prototypeID += "_ID_Count"
+ depth = "0"
+ return (prototypeID, depth)
+
+
+def InterfacePrototypeObjectProtoGetter(descriptor):
+ """
+ Returns a tuple with two elements:
+
+ 1) The name of the function to call to get the prototype to use for the
+ interface prototype object as a JSObject*.
+
+ 2) The name of the function to call to get the prototype to use for the
+ interface prototype object as a JS::Handle<JSObject*> or None if no
+ such function exists.
+ """
+ parentProtoName = descriptor.parentPrototypeName
+ if descriptor.hasNamedPropertiesObject:
+ protoGetter = "GetNamedPropertiesObject"
+ protoHandleGetter = None
+ elif parentProtoName is None:
+ if descriptor.interface.getExtendedAttribute("ArrayClass"):
+ protoGetter = "JS::GetRealmArrayPrototype"
+ elif descriptor.interface.getExtendedAttribute("ExceptionClass"):
+ protoGetter = "JS::GetRealmErrorPrototype"
+ elif descriptor.interface.isIteratorInterface():
+ protoGetter = "JS::GetRealmIteratorPrototype"
+ else:
+ protoGetter = "JS::GetRealmObjectPrototype"
+ protoHandleGetter = None
+ else:
+ prefix = toBindingNamespace(parentProtoName)
+ protoGetter = prefix + "::GetProtoObject"
+ protoHandleGetter = prefix + "::GetProtoObjectHandle"
+
+ return (protoGetter, protoHandleGetter)
+
+
+class CGPrototypeJSClass(CGThing):
+ def __init__(self, descriptor, properties):
+ CGThing.__init__(self)
+ self.descriptor = descriptor
+ self.properties = properties
+
+ def declare(self):
+ # We're purely for internal consumption
+ return ""
+
+ def define(self):
+ prototypeID, depth = PrototypeIDAndDepth(self.descriptor)
+ slotCount = "DOM_INTERFACE_PROTO_SLOTS_BASE"
+ # Globals handle unforgeables directly in Wrap() instead of
+ # via a holder.
+ if (self.descriptor.hasUnforgeableMembers and
+ not self.descriptor.isGlobal()):
+ slotCount += " + 1 /* slot for the JSObject holding the unforgeable properties */"
+ (protoGetter, _) = InterfacePrototypeObjectProtoGetter(self.descriptor)
+ type = "eGlobalInterfacePrototype" if self.descriptor.isGlobal() else "eInterfacePrototype"
+ return fill(
+ """
+ static const DOMIfaceAndProtoJSClass sPrototypeClass = {
+ {
+ "${name}Prototype",
+ JSCLASS_IS_DOMIFACEANDPROTOJSCLASS | JSCLASS_HAS_RESERVED_SLOTS(${slotCount}),
+ JS_NULL_CLASS_OPS,
+ JS_NULL_CLASS_SPEC,
+ JS_NULL_CLASS_EXT,
+ JS_NULL_OBJECT_OPS
+ },
+ ${type},
+ false,
+ ${prototypeID},
+ ${depth},
+ ${hooks},
+ "[object ${name}Prototype]",
+ ${protoGetter}
+ };
+ """,
+ name=self.descriptor.interface.identifier.name,
+ slotCount=slotCount,
+ type=type,
+ hooks=NativePropertyHooks(self.descriptor),
+ prototypeID=prototypeID,
+ depth=depth,
+ protoGetter=protoGetter)
+
+
+def NeedsGeneratedHasInstance(descriptor):
+ assert descriptor.interface.hasInterfaceObject()
+ return descriptor.hasXPConnectImpls or descriptor.interface.isConsequential()
+
+
+def InterfaceObjectProtoGetter(descriptor, forXrays=False):
+ """
+ Returns a tuple with two elements:
+
+ 1) The name of the function to call to get the prototype to use for the
+ interface object as a JSObject*.
+
+ 2) The name of the function to call to get the prototype to use for the
+ interface prototype as a JS::Handle<JSObject*> or None if no such
+ function exists.
+ """
+ parentInterface = descriptor.interface.parent
+ if parentInterface:
+ assert not descriptor.interface.isNamespace()
+ parentIfaceName = parentInterface.identifier.name
+ parentDesc = descriptor.getDescriptor(parentIfaceName)
+ prefix = toBindingNamespace(parentDesc.name)
+ protoGetter = prefix + "::GetConstructorObject"
+ protoHandleGetter = prefix + "::GetConstructorObjectHandle"
+ elif descriptor.interface.isNamespace():
+ if (forXrays or
+ not descriptor.interface.getExtendedAttribute("ProtoObjectHack")):
+ protoGetter = "JS::GetRealmObjectPrototype"
+ else:
+ protoGetter = "binding_detail::GetHackedNamespaceProtoObject"
+ protoHandleGetter = None
+ else:
+ protoGetter = "JS::GetRealmFunctionPrototype"
+ protoHandleGetter = None
+ return (protoGetter, protoHandleGetter)
+
+
+class CGInterfaceObjectJSClass(CGThing):
+ def __init__(self, descriptor, properties):
+ CGThing.__init__(self)
+ self.descriptor = descriptor
+ self.properties = properties
+
+ def declare(self):
+ # We're purely for internal consumption
+ return ""
+
+ def define(self):
+ if self.descriptor.interface.ctor():
+ assert not self.descriptor.interface.isNamespace()
+ ctorname = CONSTRUCT_HOOK_NAME
+ elif self.descriptor.interface.isNamespace():
+ ctorname = "nullptr"
+ else:
+ ctorname = "ThrowingConstructor"
+ needsHasInstance = (
+ not NeedsGeneratedHasInstance(self.descriptor) and
+ self.descriptor.interface.hasInterfacePrototypeObject())
+
+ prototypeID, depth = PrototypeIDAndDepth(self.descriptor)
+ slotCount = "DOM_INTERFACE_SLOTS_BASE"
+ if len(self.descriptor.interface.namedConstructors) > 0:
+ slotCount += (" + %i /* slots for the named constructors */" %
+ len(self.descriptor.interface.namedConstructors))
+ (protoGetter, _) = InterfaceObjectProtoGetter(self.descriptor,
+ forXrays=True)
+
+ if ctorname == "ThrowingConstructor":
+ ret = ""
+ classOpsPtr = "&sBoringInterfaceObjectClassClassOps"
+ elif ctorname == "nullptr":
+ ret = ""
+ classOpsPtr = "JS_NULL_CLASS_OPS"
+ else:
+ ret = fill(
+ """
+ static const js::ClassOps sInterfaceObjectClassOps = {
+ nullptr, /* addProperty */
+ nullptr, /* delProperty */
+ nullptr, /* getProperty */
+ nullptr, /* setProperty */
+ nullptr, /* enumerate */
+ nullptr, /* resolve */
+ nullptr, /* mayResolve */
+ nullptr, /* finalize */
+ ${ctorname}, /* call */
+ nullptr, /* hasInstance */
+ ${ctorname}, /* construct */
+ nullptr, /* trace */
+ };
+
+ """,
+ ctorname=ctorname)
+ classOpsPtr = "&sInterfaceObjectClassOps"
+
+ if self.descriptor.interface.isNamespace():
+ classString = self.descriptor.interface.getExtendedAttribute("ClassString")
+ if classString is None:
+ classString = "Object"
+ else:
+ classString = classString[0]
+ toStringResult = "[object %s]" % classString
+ objectOps = "JS_NULL_OBJECT_OPS"
+ else:
+ classString = "Function"
+ toStringResult = ("function %s() {\\n [native code]\\n}" %
+ self.descriptor.interface.identifier.name)
+ # We need non-default ObjectOps so we can actually make
+ # use of our toStringResult.
+ objectOps = "&sInterfaceObjectClassObjectOps"
+
+ ret = ret + fill(
+ """
+ static const DOMIfaceAndProtoJSClass sInterfaceObjectClass = {
+ {
+ "${classString}",
+ JSCLASS_IS_DOMIFACEANDPROTOJSCLASS | JSCLASS_HAS_RESERVED_SLOTS(${slotCount}),
+ ${classOpsPtr},
+ JS_NULL_CLASS_SPEC,
+ JS_NULL_CLASS_EXT,
+ ${objectOps}
+ },
+ eInterface,
+ ${needsHasInstance},
+ ${prototypeID},
+ ${depth},
+ ${hooks},
+ "${toStringResult}",
+ ${protoGetter}
+ };
+ """,
+ classString=classString,
+ slotCount=slotCount,
+ classOpsPtr=classOpsPtr,
+ hooks=NativePropertyHooks(self.descriptor),
+ objectOps=objectOps,
+ needsHasInstance=toStringBool(needsHasInstance),
+ prototypeID=prototypeID,
+ depth=depth,
+ toStringResult=toStringResult,
+ protoGetter=protoGetter)
+ return ret
+
+class CGList(CGThing):
+ """
+ Generate code for a list of GCThings. Just concatenates them together, with
+ an optional joiner string. "\n" is a common joiner.
+ """
+ def __init__(self, children, joiner=""):
+ CGThing.__init__(self)
+ # Make a copy of the kids into a list, because if someone passes in a
+ # generator we won't be able to both declare and define ourselves, or
+ # define ourselves more than once!
+ self.children = list(children)
+ self.joiner = joiner
+
+ def append(self, child):
+ self.children.append(child)
+
+ def prepend(self, child):
+ self.children.insert(0, child)
+
+ def extend(self, kids):
+ self.children.extend(kids)
+
+ def join(self, iterable):
+ return self.joiner.join(s for s in iterable if len(s) > 0)
+
+ def declare(self):
+ return self.join(child.declare() for child in self.children if child is not None)
+
+ def define(self):
+ return self.join(child.define() for child in self.children if child is not None)
+
+ def deps(self):
+ deps = set()
+ for child in self.children:
+ if child is None:
+ continue
+ deps = deps.union(child.deps())
+ return deps
+
+ def __len__(self):
+ return len(self.children)
+
+
+class CGGeneric(CGThing):
+ """
+ A class that spits out a fixed string into the codegen. Can spit out a
+ separate string for the declaration too.
+ """
+ def __init__(self, define="", declare=""):
+ self.declareText = declare
+ self.defineText = define
+
+ def declare(self):
+ return self.declareText
+
+ def define(self):
+ return self.defineText
+
+ def deps(self):
+ return set()
+
+
+class CGIndenter(CGThing):
+ """
+ A class that takes another CGThing and generates code that indents that
+ CGThing by some number of spaces. The default indent is two spaces.
+ """
+ def __init__(self, child, indentLevel=2, declareOnly=False):
+ assert isinstance(child, CGThing)
+ CGThing.__init__(self)
+ self.child = child
+ self.indentLevel = indentLevel
+ self.declareOnly = declareOnly
+
+ def declare(self):
+ return indent(self.child.declare(), self.indentLevel)
+
+ def define(self):
+ defn = self.child.define()
+ if self.declareOnly:
+ return defn
+ else:
+ return indent(defn, self.indentLevel)
+
+
+class CGWrapper(CGThing):
+ """
+ Generic CGThing that wraps other CGThings with pre and post text.
+ """
+ def __init__(self, child, pre="", post="", declarePre=None,
+ declarePost=None, definePre=None, definePost=None,
+ declareOnly=False, defineOnly=False, reindent=False):
+ CGThing.__init__(self)
+ self.child = child
+ self.declarePre = declarePre or pre
+ self.declarePost = declarePost or post
+ self.definePre = definePre or pre
+ self.definePost = definePost or post
+ self.declareOnly = declareOnly
+ self.defineOnly = defineOnly
+ self.reindent = reindent
+
+ def declare(self):
+ if self.defineOnly:
+ return ''
+ decl = self.child.declare()
+ if self.reindent:
+ decl = self.reindentString(decl, self.declarePre)
+ return self.declarePre + decl + self.declarePost
+
+ def define(self):
+ if self.declareOnly:
+ return ''
+ defn = self.child.define()
+ if self.reindent:
+ defn = self.reindentString(defn, self.definePre)
+ return self.definePre + defn + self.definePost
+
+ @staticmethod
+ def reindentString(stringToIndent, widthString):
+ # We don't use lineStartDetector because we don't want to
+ # insert whitespace at the beginning of our _first_ line.
+ # Use the length of the last line of width string, in case
+ # it is a multiline string.
+ lastLineWidth = len(widthString.splitlines()[-1])
+ return stripTrailingWhitespace(
+ stringToIndent.replace("\n", "\n" + (" " * lastLineWidth)))
+
+ def deps(self):
+ return self.child.deps()
+
+
+class CGIfWrapper(CGList):
+ def __init__(self, child, condition):
+ CGList.__init__(self, [
+ CGWrapper(CGGeneric(condition), pre="if (", post=") {\n", reindent=True),
+ CGIndenter(child),
+ CGGeneric("}\n")
+ ])
+
+
+class CGIfElseWrapper(CGList):
+ def __init__(self, condition, ifTrue, ifFalse):
+ CGList.__init__(self, [
+ CGWrapper(CGGeneric(condition), pre="if (", post=") {\n", reindent=True),
+ CGIndenter(ifTrue),
+ CGGeneric("} else {\n"),
+ CGIndenter(ifFalse),
+ CGGeneric("}\n")
+ ])
+
+
+class CGElseChain(CGThing):
+ """
+ Concatenate if statements in an if-else-if-else chain.
+ """
+ def __init__(self, children):
+ self.children = [c for c in children if c is not None]
+
+ def declare(self):
+ assert False
+
+ def define(self):
+ if not self.children:
+ return ""
+ s = self.children[0].define()
+ assert s.endswith("\n")
+ for child in self.children[1:]:
+ code = child.define()
+ assert code.startswith("if") or code.startswith("{")
+ assert code.endswith("\n")
+ s = s.rstrip() + " else " + code
+ return s
+
+
+class CGTemplatedType(CGWrapper):
+ def __init__(self, templateName, child, isConst=False, isReference=False):
+ const = "const " if isConst else ""
+ pre = "%s%s<" % (const, templateName)
+ ref = "&" if isReference else ""
+ post = ">%s" % ref
+ CGWrapper.__init__(self, child, pre=pre, post=post)
+
+
+class CGNamespace(CGWrapper):
+ def __init__(self, namespace, child, declareOnly=False):
+ pre = "namespace %s {\n" % namespace
+ post = "} // namespace %s\n" % namespace
+ CGWrapper.__init__(self, child, pre=pre, post=post,
+ declareOnly=declareOnly)
+
+ @staticmethod
+ def build(namespaces, child, declareOnly=False):
+ """
+ Static helper method to build multiple wrapped namespaces.
+ """
+ if not namespaces:
+ return CGWrapper(child, declareOnly=declareOnly)
+ inner = CGNamespace.build(namespaces[1:], child, declareOnly=declareOnly)
+ return CGNamespace(namespaces[0], inner, declareOnly=declareOnly)
+
+
+class CGIncludeGuard(CGWrapper):
+ """
+ Generates include guards for a header.
+ """
+ def __init__(self, prefix, child):
+ """|prefix| is the filename without the extension."""
+ define = 'mozilla_dom_%s_h' % prefix
+ CGWrapper.__init__(self, child,
+ declarePre='#ifndef %s\n#define %s\n\n' % (define, define),
+ declarePost='\n#endif // %s\n' % define)
+
+
+class CGHeaders(CGWrapper):
+ """
+ Generates the appropriate include statements.
+ """
+ def __init__(self, descriptors, dictionaries, callbacks,
+ callbackDescriptors,
+ declareIncludes, defineIncludes, prefix, child,
+ config=None, jsImplementedDescriptors=[]):
+ """
+ Builds a set of includes to cover |descriptors|.
+
+ Also includes the files in |declareIncludes| in the header
+ file and the files in |defineIncludes| in the .cpp.
+
+ |prefix| contains the basename of the file that we generate include
+ statements for.
+ """
+
+ # Determine the filenames for which we need headers.
+ interfaceDeps = [d.interface for d in descriptors]
+ ancestors = []
+ for iface in interfaceDeps:
+ if iface.parent:
+ # We're going to need our parent's prototype, to use as the
+ # prototype of our prototype object.
+ ancestors.append(iface.parent)
+ # And if we have an interface object, we'll need the nearest
+ # ancestor with an interface object too, so we can use its
+ # interface object as the proto of our interface object.
+ if iface.hasInterfaceObject():
+ parent = iface.parent
+ while parent and not parent.hasInterfaceObject():
+ parent = parent.parent
+ if parent:
+ ancestors.append(parent)
+ interfaceDeps.extend(ancestors)
+ bindingIncludes = set(self.getDeclarationFilename(d) for d in interfaceDeps)
+
+ # Grab all the implementation declaration files we need.
+ implementationIncludes = set(d.headerFile for d in descriptors if d.needsHeaderInclude())
+
+ # Grab the includes for checking hasInstance
+ interfacesImplementingSelf = set()
+ for d in descriptors:
+ interfacesImplementingSelf |= d.interface.interfacesImplementingSelf
+ implementationIncludes |= set(self.getDeclarationFilename(i) for i in
+ interfacesImplementingSelf)
+
+ # Grab the includes for the things that involve XPCOM interfaces
+ hasInstanceIncludes = set("nsIDOM" + d.interface.identifier.name + ".h" for d
+ in descriptors if
+ d.interface.hasInterfaceObject() and
+ NeedsGeneratedHasInstance(d) and
+ d.interface.hasInterfacePrototypeObject())
+ if len(hasInstanceIncludes) > 0:
+ hasInstanceIncludes.add("nsContentUtils.h")
+
+ # Now find all the things we'll need as arguments because we
+ # need to wrap or unwrap them.
+ bindingHeaders = set()
+ declareIncludes = set(declareIncludes)
+
+ def addHeadersForType((t, dictionary)):
+ """
+ Add the relevant headers for this type. We use dictionary, if
+ passed, to decide what to do with interface types.
+ """
+ # Dictionaries have members that need to be actually
+ # declared, not just forward-declared.
+ if dictionary:
+ headerSet = declareIncludes
+ else:
+ headerSet = bindingHeaders
+ if t.nullable():
+ # Need to make sure that Nullable as a dictionary
+ # member works.
+ headerSet.add("mozilla/dom/Nullable.h")
+ unrolled = t.unroll()
+ if unrolled.isUnion():
+ headerSet.add(self.getUnionDeclarationFilename(config, unrolled))
+ bindingHeaders.add("mozilla/dom/UnionConversions.h")
+ elif unrolled.isDate():
+ if dictionary or jsImplementedDescriptors:
+ declareIncludes.add("mozilla/dom/Date.h")
+ else:
+ bindingHeaders.add("mozilla/dom/Date.h")
+ elif unrolled.isInterface():
+ if unrolled.isSpiderMonkeyInterface():
+ bindingHeaders.add("jsfriendapi.h")
+ if jsImplementedDescriptors:
+ # Since we can't forward-declare typed array types
+ # (because they're typedefs), we have to go ahead and
+ # just include their header if we need to have functions
+ # taking references to them declared in that header.
+ headerSet = declareIncludes
+ headerSet.add("mozilla/dom/TypedArray.h")
+ else:
+ try:
+ typeDesc = config.getDescriptor(unrolled.inner.identifier.name)
+ except NoSuchDescriptorError:
+ return
+ # Dictionaries with interface members rely on the
+ # actual class definition of that interface member
+ # being visible in the binding header, because they
+ # store them in RefPtr and have inline
+ # constructors/destructors.
+ #
+ # XXXbz maybe dictionaries with interface members
+ # should just have out-of-line constructors and
+ # destructors?
+ headerSet.add(typeDesc.headerFile)
+ elif unrolled.isDictionary():
+ headerSet.add(self.getDeclarationFilename(unrolled.inner))
+ elif unrolled.isCallback():
+ headerSet.add(self.getDeclarationFilename(unrolled.callback))
+ elif unrolled.isFloat() and not unrolled.isUnrestricted():
+ # Restricted floats are tested for finiteness
+ bindingHeaders.add("mozilla/FloatingPoint.h")
+ bindingHeaders.add("mozilla/dom/PrimitiveConversions.h")
+ elif unrolled.isEnum():
+ filename = self.getDeclarationFilename(unrolled.inner)
+ declareIncludes.add(filename)
+ elif unrolled.isPrimitive():
+ bindingHeaders.add("mozilla/dom/PrimitiveConversions.h")
+ elif unrolled.isMozMap():
+ if dictionary or jsImplementedDescriptors:
+ declareIncludes.add("mozilla/dom/MozMap.h")
+ else:
+ bindingHeaders.add("mozilla/dom/MozMap.h")
+ # Also add headers for the type the MozMap is
+ # parametrized over, if needed.
+ addHeadersForType((t.inner, dictionary))
+
+ map(addHeadersForType,
+ getAllTypes(descriptors + callbackDescriptors, dictionaries,
+ callbacks))
+
+ # Now make sure we're not trying to include the header from inside itself
+ declareIncludes.discard(prefix + ".h")
+
+ def addHeaderForFunc(func, desc):
+ if func is None:
+ return
+ # Include the right class header, which we can only do
+ # if this is a class member function.
+ if desc is not None and not desc.headerIsDefault:
+ # An explicit header file was provided, assume that we know
+ # what we're doing.
+ return
+
+ if "::" in func:
+ # Strip out the function name and convert "::" to "/"
+ bindingHeaders.add("/".join(func.split("::")[:-1]) + ".h")
+
+ # Now for non-callback descriptors make sure we include any
+ # headers needed by Func declarations and other things like that.
+ for desc in descriptors:
+ # If this is an iterator interface generated for a seperate
+ # iterable interface, skip generating type includes, as we have
+ # what we need in IterableIterator.h
+ if desc.interface.isExternal() or desc.interface.isIteratorInterface():
+ continue
+
+ for m in desc.interface.members:
+ addHeaderForFunc(PropertyDefiner.getStringAttr(m, "Func"), desc)
+ staticTypeOverride = PropertyDefiner.getStringAttr(m, "StaticClassOverride")
+ if staticTypeOverride:
+ bindingHeaders.add("/".join(staticTypeOverride.split("::")) + ".h")
+ # getExtendedAttribute() returns a list, extract the entry.
+ funcList = desc.interface.getExtendedAttribute("Func")
+ if funcList is not None:
+ addHeaderForFunc(funcList[0], desc)
+
+ if desc.interface.maplikeOrSetlikeOrIterable:
+ # We need ToJSValue.h for maplike/setlike type conversions
+ bindingHeaders.add("mozilla/dom/ToJSValue.h")
+ # Add headers for the key and value types of the
+ # maplike/setlike/iterable, since they'll be needed for
+ # convenience functions
+ if desc.interface.maplikeOrSetlikeOrIterable.hasKeyType():
+ addHeadersForType((desc.interface.maplikeOrSetlikeOrIterable.keyType,
+ None))
+ if desc.interface.maplikeOrSetlikeOrIterable.hasValueType():
+ addHeadersForType((desc.interface.maplikeOrSetlikeOrIterable.valueType,
+ None))
+
+ for d in dictionaries:
+ if d.parent:
+ declareIncludes.add(self.getDeclarationFilename(d.parent))
+ bindingHeaders.add(self.getDeclarationFilename(d))
+ for m in d.members:
+ addHeaderForFunc(PropertyDefiner.getStringAttr(m, "Func"),
+ None)
+ # No need to worry about Func on members of ancestors, because that
+ # will happen automatically in whatever files those ancestors live
+ # in.
+
+ for c in callbacks:
+ bindingHeaders.add(self.getDeclarationFilename(c))
+
+ for c in callbackDescriptors:
+ bindingHeaders.add(self.getDeclarationFilename(c.interface))
+
+ if len(callbacks) != 0:
+ # We need CallbackFunction to serve as our parent class
+ declareIncludes.add("mozilla/dom/CallbackFunction.h")
+ # And we need ToJSValue.h so we can wrap "this" objects
+ declareIncludes.add("mozilla/dom/ToJSValue.h")
+
+ if len(callbackDescriptors) != 0 or len(jsImplementedDescriptors) != 0:
+ # We need CallbackInterface to serve as our parent class
+ declareIncludes.add("mozilla/dom/CallbackInterface.h")
+ # And we need ToJSValue.h so we can wrap "this" objects
+ declareIncludes.add("mozilla/dom/ToJSValue.h")
+
+ # Also need to include the headers for ancestors of
+ # JS-implemented interfaces.
+ for jsImplemented in jsImplementedDescriptors:
+ jsParent = jsImplemented.interface.parent
+ if jsParent:
+ parentDesc = jsImplemented.getDescriptor(jsParent.identifier.name)
+ declareIncludes.add(parentDesc.jsImplParentHeader)
+
+ # Let the machinery do its thing.
+ def _includeString(includes):
+ return ''.join(['#include "%s"\n' % i for i in includes]) + '\n'
+ CGWrapper.__init__(self, child,
+ declarePre=_includeString(sorted(declareIncludes)),
+ definePre=_includeString(sorted(set(defineIncludes) |
+ bindingIncludes |
+ bindingHeaders |
+ hasInstanceIncludes |
+ implementationIncludes)))
+
+ @staticmethod
+ def getDeclarationFilename(decl):
+ # 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(decl.filename())
+ return basename.replace('.webidl', 'Binding.h')
+
+ @staticmethod
+ def getUnionDeclarationFilename(config, unionType):
+ assert unionType.isUnion()
+ assert unionType.unroll() == unionType
+ # If a union is "defined" in multiple files, it goes in UnionTypes.h.
+ if len(config.filenamesPerUnion[unionType.name]) > 1:
+ return "mozilla/dom/UnionTypes.h"
+ # If a union is defined by a built-in typedef, it also goes in
+ # UnionTypes.h.
+ assert len(config.filenamesPerUnion[unionType.name]) == 1
+ if "<unknown>" in config.filenamesPerUnion[unionType.name]:
+ return "mozilla/dom/UnionTypes.h"
+ return CGHeaders.getDeclarationFilename(unionType)
+
+
+def SortedDictValues(d):
+ """
+ Returns a list of values from the dict sorted by key.
+ """
+ return [v for k, v in sorted(d.items())]
+
+
+def UnionsForFile(config, webIDLFile):
+ """
+ Returns a list of union types for all union types that are only used in
+ webIDLFile. If webIDLFile is None this will return the list of tuples for
+ union types that are used in more than one WebIDL file.
+ """
+ return config.unionsPerFilename.get(webIDLFile, [])
+
+
+def UnionTypes(unionTypes, config):
+ """
+ The unionTypes argument should be a list of union types. This is typically
+ the list generated by UnionsForFile.
+
+ Returns a tuple containing a set of header filenames to include in
+ the header for the types in unionTypes, a set of header filenames to
+ include in the implementation file for the types in unionTypes, a set
+ of tuples containing a type declaration and a boolean if the type is a
+ struct for member types of the union, a list of traverse methods,
+ unlink methods and a list of union types. These last three lists only
+ contain unique union types.
+ """
+
+ headers = set()
+ implheaders = set()
+ declarations = set()
+ unionStructs = dict()
+ traverseMethods = dict()
+ unlinkMethods = dict()
+
+ for t in unionTypes:
+ name = str(t)
+ if name not in unionStructs:
+ unionStructs[name] = t
+
+ def addHeadersForType(f):
+ if f.nullable():
+ headers.add("mozilla/dom/Nullable.h")
+ isSequence = f.isSequence()
+ f = f.unroll()
+ if f.isInterface():
+ if f.isSpiderMonkeyInterface():
+ headers.add("jsfriendapi.h")
+ headers.add("mozilla/dom/TypedArray.h")
+ else:
+ try:
+ typeDesc = config.getDescriptor(f.inner.identifier.name)
+ except NoSuchDescriptorError:
+ return
+ if typeDesc.interface.isCallback() or isSequence:
+ # Callback interfaces always use strong refs, so
+ # we need to include the right header to be able
+ # to Release() in our inlined code.
+ #
+ # Similarly, sequences always contain strong
+ # refs, so we'll need the header to handler
+ # those.
+ headers.add(typeDesc.headerFile)
+ else:
+ declarations.add((typeDesc.nativeType, False))
+ implheaders.add(typeDesc.headerFile)
+ elif f.isDictionary():
+ # For a dictionary, we need to see its declaration in
+ # UnionTypes.h so we have its sizeof and know how big to
+ # make our union.
+ headers.add(CGHeaders.getDeclarationFilename(f.inner))
+ # And if it needs rooting, we need RootedDictionary too
+ if typeNeedsRooting(f):
+ headers.add("mozilla/dom/RootedDictionary.h")
+ elif f.isEnum():
+ # Need to see the actual definition of the enum,
+ # unfortunately.
+ headers.add(CGHeaders.getDeclarationFilename(f.inner))
+ elif f.isCallback():
+ # Callbacks always use strong refs, so we need to include
+ # the right header to be able to Release() in our inlined
+ # code.
+ headers.add(CGHeaders.getDeclarationFilename(f.callback))
+ elif f.isMozMap():
+ headers.add("mozilla/dom/MozMap.h")
+ # And add headers for the type we're parametrized over
+ addHeadersForType(f.inner)
+
+ implheaders.add(CGHeaders.getUnionDeclarationFilename(config, t))
+ for f in t.flatMemberTypes:
+ assert not f.nullable()
+ addHeadersForType(f)
+
+ if idlTypeNeedsCycleCollection(t):
+ declarations.add(("mozilla::dom::%s" % CGUnionStruct.unionTypeName(t, True), False))
+ traverseMethods[name] = CGCycleCollectionTraverseForOwningUnionMethod(t)
+ unlinkMethods[name] = CGCycleCollectionUnlinkForOwningUnionMethod(t)
+
+ # The order of items in CGList is important.
+ # Since the union structs friend the unlinkMethods, the forward-declaration
+ # for these methods should come before the class declaration. Otherwise
+ # some compilers treat the friend declaration as a forward-declaration in
+ # the class scope.
+ return (headers, implheaders, declarations,
+ SortedDictValues(traverseMethods), SortedDictValues(unlinkMethods),
+ SortedDictValues(unionStructs))
+
+
+def UnionConversions(unionTypes, config):
+ """
+ The unionTypes argument should be a list of tuples, each containing two
+ elements: a union type and a descriptor. This is typically the list
+ generated by UnionsForFile.
+
+ Returns a tuple containing a list of headers and a CGThing to declare all
+ union argument conversion helper structs.
+ """
+ headers = set()
+ unionConversions = dict()
+
+ for t in unionTypes:
+ name = str(t)
+ if name not in unionConversions:
+ unionConversions[name] = CGUnionConversionStruct(t, config)
+
+ def addHeadersForType(f):
+ f = f.unroll()
+ if f.isInterface():
+ if f.isSpiderMonkeyInterface():
+ headers.add("jsfriendapi.h")
+ headers.add("mozilla/dom/TypedArray.h")
+ elif f.inner.isExternal():
+ try:
+ typeDesc = config.getDescriptor(f.inner.identifier.name)
+ except NoSuchDescriptorError:
+ return
+ headers.add(typeDesc.headerFile)
+ else:
+ headers.add(CGHeaders.getDeclarationFilename(f.inner))
+ elif f.isDictionary():
+ headers.add(CGHeaders.getDeclarationFilename(f.inner))
+ elif f.isPrimitive():
+ headers.add("mozilla/dom/PrimitiveConversions.h")
+ elif f.isMozMap():
+ headers.add("mozilla/dom/MozMap.h")
+ # And the internal type of the MozMap
+ addHeadersForType(f.inner)
+
+ # We plan to include UnionTypes.h no matter what, so it's
+ # OK if we throw it into the set here.
+ headers.add(CGHeaders.getUnionDeclarationFilename(config, t))
+
+ for f in t.flatMemberTypes:
+ addHeadersForType(f)
+
+ return (headers,
+ CGWrapper(CGList(SortedDictValues(unionConversions), "\n"),
+ post="\n\n"))
+
+
+class Argument():
+ """
+ A class for outputting the type and name of an argument
+ """
+ def __init__(self, argType, name, default=None):
+ self.argType = argType
+ self.name = name
+ self.default = default
+
+ def declare(self):
+ string = self.argType + ' ' + self.name
+ if self.default is not None:
+ string += " = " + self.default
+ return string
+
+ def define(self):
+ return self.argType + ' ' + self.name
+
+
+class CGAbstractMethod(CGThing):
+ """
+ An abstract class for generating code for a method. Subclasses
+ should override definition_body to create the actual code.
+
+ descriptor is the descriptor for the interface the method is associated with
+
+ name is the name of the method as a string
+
+ returnType is the IDLType of the return value
+
+ args is a list of Argument objects
+
+ inline should be True to generate an inline method, whose body is
+ part of the declaration.
+
+ alwaysInline should be True to generate an inline method annotated with
+ MOZ_ALWAYS_INLINE.
+
+ static should be True to generate a static method, which only has
+ a definition.
+
+ If templateArgs is not None it should be a list of strings containing
+ template arguments, and the function will be templatized using those
+ arguments.
+ """
+ def __init__(self, descriptor, name, returnType, args, inline=False, alwaysInline=False, static=False, templateArgs=None):
+ CGThing.__init__(self)
+ self.descriptor = descriptor
+ self.name = name
+ self.returnType = returnType
+ self.args = args
+ self.inline = inline
+ self.alwaysInline = alwaysInline
+ self.static = static
+ self.templateArgs = templateArgs
+
+ def _argstring(self, declare):
+ return ', '.join([a.declare() if declare else a.define() for a in self.args])
+
+ def _template(self):
+ if self.templateArgs is None:
+ return ''
+ return 'template <%s>\n' % ', '.join(self.templateArgs)
+
+ def _decorators(self):
+ decorators = []
+ if self.alwaysInline:
+ decorators.append('MOZ_ALWAYS_INLINE')
+ elif self.inline:
+ decorators.append('inline')
+ if self.static:
+ decorators.append('static')
+ decorators.append(self.returnType)
+ maybeNewline = " " if self.inline else "\n"
+ return ' '.join(decorators) + maybeNewline
+
+ def declare(self):
+ if self.inline:
+ return self._define(True)
+ return "%s%s%s(%s);\n" % (self._template(), self._decorators(), self.name, self._argstring(True))
+
+ def indent_body(self, body):
+ """
+ Indent the code returned by self.definition_body(). Most classes
+ simply indent everything two spaces. This is here for
+ CGRegisterProtos, which needs custom indentation.
+ """
+ return indent(body)
+
+ def _define(self, fromDeclare=False):
+ return (self.definition_prologue(fromDeclare) +
+ self.indent_body(self.definition_body()) +
+ self.definition_epilogue())
+
+ def define(self):
+ return "" if self.inline else self._define()
+
+ def definition_prologue(self, fromDeclare):
+ return "%s%s%s(%s)\n{\n" % (self._template(), self._decorators(),
+ self.name, self._argstring(fromDeclare))
+
+ def definition_epilogue(self):
+ return "}\n"
+
+ def definition_body(self):
+ assert False # Override me!
+
+
+class CGAbstractStaticMethod(CGAbstractMethod):
+ """
+ Abstract base class for codegen of implementation-only (no
+ declaration) static methods.
+ """
+ def __init__(self, descriptor, name, returnType, args):
+ CGAbstractMethod.__init__(self, descriptor, name, returnType, args,
+ inline=False, static=True)
+
+ def declare(self):
+ # We only have implementation
+ return ""
+
+
+class CGAbstractClassHook(CGAbstractStaticMethod):
+ """
+ Meant for implementing JSClass hooks, like Finalize or Trace. Does very raw
+ 'this' unwrapping as it assumes that the unwrapped type is always known.
+ """
+ def __init__(self, descriptor, name, returnType, args):
+ CGAbstractStaticMethod.__init__(self, descriptor, name, returnType,
+ args)
+
+ def definition_body_prologue(self):
+ return ("%s* self = UnwrapPossiblyNotInitializedDOMObject<%s>(obj);\n" %
+ (self.descriptor.nativeType, self.descriptor.nativeType))
+
+ def definition_body(self):
+ return self.definition_body_prologue() + self.generate_code()
+
+ def generate_code(self):
+ assert False # Override me!
+
+
+class CGGetJSClassMethod(CGAbstractMethod):
+ def __init__(self, descriptor):
+ CGAbstractMethod.__init__(self, descriptor, 'GetJSClass', 'const JSClass*',
+ [])
+
+ def definition_body(self):
+ return "return sClass.ToJSClass();\n"
+
+
+class CGAddPropertyHook(CGAbstractClassHook):
+ """
+ A hook for addProperty, used to preserve our wrapper from GC.
+ """
+ def __init__(self, descriptor):
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'obj'),
+ Argument('JS::Handle<jsid>', 'id'),
+ Argument('JS::Handle<JS::Value>', 'val')]
+ CGAbstractClassHook.__init__(self, descriptor, ADDPROPERTY_HOOK_NAME,
+ 'bool', args)
+
+ def generate_code(self):
+ assert self.descriptor.wrapperCache
+ return dedent("""
+ // We don't want to preserve if we don't have a wrapper, and we
+ // obviously can't preserve if we're not initialized.
+ if (self && self->GetWrapperPreserveColor()) {
+ PreserveWrapper(self);
+ }
+ return true;
+ """)
+
+
+def finalizeHook(descriptor, hookName, freeOp):
+ finalize = ""
+ if descriptor.wrapperCache:
+ finalize += "ClearWrapper(self, self);\n"
+ if descriptor.interface.getExtendedAttribute('OverrideBuiltins'):
+ finalize += "self->mExpandoAndGeneration.expando = JS::UndefinedValue();\n"
+ if descriptor.isGlobal():
+ finalize += "mozilla::dom::FinalizeGlobal(CastToJSFreeOp(%s), obj);\n" % freeOp
+ finalize += ("AddForDeferredFinalization<%s>(self);\n" %
+ descriptor.nativeType)
+ return CGIfWrapper(CGGeneric(finalize), "self")
+
+
+class CGClassFinalizeHook(CGAbstractClassHook):
+ """
+ A hook for finalize, used to release our native object.
+ """
+ def __init__(self, descriptor):
+ args = [Argument('js::FreeOp*', 'fop'), Argument('JSObject*', 'obj')]
+ CGAbstractClassHook.__init__(self, descriptor, FINALIZE_HOOK_NAME,
+ 'void', args)
+
+ def generate_code(self):
+ return finalizeHook(self.descriptor, self.name, self.args[0].name).define()
+
+
+class CGClassObjectMovedHook(CGAbstractClassHook):
+ """
+ A hook for objectMovedOp, used to update the wrapper cache when an object it
+ is holding moves.
+ """
+ def __init__(self, descriptor):
+ args = [Argument('JSObject*', 'obj'), Argument('const JSObject*', 'old')]
+ CGAbstractClassHook.__init__(self, descriptor, OBJECT_MOVED_HOOK_NAME,
+ 'void', args)
+
+ def generate_code(self):
+ assert self.descriptor.wrapperCache
+ return CGIfWrapper(CGGeneric("UpdateWrapper(self, self, obj, old);\n"),
+ "self").define()
+
+
+def JSNativeArguments():
+ return [Argument('JSContext*', 'cx'),
+ Argument('unsigned', 'argc'),
+ Argument('JS::Value*', 'vp')]
+
+
+class CGClassConstructor(CGAbstractStaticMethod):
+ """
+ JS-visible constructor for our objects
+ """
+ def __init__(self, descriptor, ctor, name=CONSTRUCT_HOOK_NAME):
+ CGAbstractStaticMethod.__init__(self, descriptor, name, 'bool',
+ JSNativeArguments())
+ self._ctor = ctor
+
+ def define(self):
+ if not self._ctor:
+ return ""
+ return CGAbstractStaticMethod.define(self)
+
+ def definition_body(self):
+ return self.generate_code()
+
+ def generate_code(self):
+ # [ChromeOnly] interfaces may only be constructed by chrome.
+ chromeOnlyCheck = ""
+ if isChromeOnly(self._ctor):
+ chromeOnlyCheck = dedent("""
+ if (!nsContentUtils::ThreadsafeIsCallerChrome()) {
+ return ThrowingConstructor(cx, argc, vp);
+ }
+
+ """)
+
+ # Additionally, we want to throw if a caller does a bareword invocation
+ # of a constructor without |new|. We don't enforce this for chrome in
+ # realease builds to avoid the addon compat fallout of making that
+ # change. See bug 916644.
+ #
+ # Figure out the name of our constructor for error reporting purposes.
+ # For unnamed webidl constructors, identifier.name is "constructor" but
+ # the name JS sees is the interface name; for named constructors
+ # identifier.name is the actual name.
+ name = self._ctor.identifier.name
+ if name != "constructor":
+ ctorName = name
+ else:
+ ctorName = self.descriptor.interface.identifier.name
+
+ preamble = fill(
+ """
+ JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
+ JS::Rooted<JSObject*> obj(cx, &args.callee());
+ $*{chromeOnlyCheck}
+ if (!args.isConstructing()) {
+ // XXXbz wish I could get the name from the callee instead of
+ // Adding more relocations
+ return ThrowConstructorWithoutNew(cx, "${ctorName}");
+ }
+ JS::Rooted<JSObject*> desiredProto(cx);
+ if (!GetDesiredProto(cx, args, &desiredProto)) {
+ return false;
+ }
+ """,
+ chromeOnlyCheck=chromeOnlyCheck,
+ ctorName=ctorName)
+
+ name = self._ctor.identifier.name
+ nativeName = MakeNativeName(self.descriptor.binaryNameFor(name))
+ callGenerator = CGMethodCall(nativeName, True, self.descriptor,
+ self._ctor, isConstructor=True,
+ constructorName=ctorName)
+ return preamble + "\n" + callGenerator.define()
+
+
+# Encapsulate the constructor in a helper method to share genConstructorBody with CGJSImplMethod.
+class CGConstructNavigatorObject(CGAbstractMethod):
+ """
+ Construct a new JS-implemented WebIDL DOM object, for use on navigator.
+ """
+ def __init__(self, descriptor):
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'obj'),
+ Argument('ErrorResult&', 'aRv')]
+ rtype = 'already_AddRefed<%s>' % descriptor.name
+ CGAbstractMethod.__init__(self, descriptor, "ConstructNavigatorObject",
+ rtype, args)
+
+ def definition_body(self):
+ if not self.descriptor.interface.isJSImplemented():
+ raise TypeError("Only JS-implemented classes are currently supported "
+ "on navigator. See bug 856820.")
+
+ return dedent(
+ """
+ GlobalObject global(cx, obj);
+ if (global.Failed()) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+ """) + genConstructorBody(self.descriptor)
+
+
+def NamedConstructorName(m):
+ return '_' + m.identifier.name
+
+
+class CGNamedConstructors(CGThing):
+ def __init__(self, descriptor):
+ self.descriptor = descriptor
+ CGThing.__init__(self)
+
+ def declare(self):
+ return ""
+
+ def define(self):
+ if len(self.descriptor.interface.namedConstructors) == 0:
+ return ""
+
+ constructorID = "constructors::id::"
+ if self.descriptor.interface.hasInterfaceObject():
+ constructorID += self.descriptor.name
+ else:
+ constructorID += "_ID_Count"
+
+ namedConstructors = ""
+ for n in self.descriptor.interface.namedConstructors:
+ namedConstructors += (
+ "{ \"%s\", { %s, &sNamedConstructorNativePropertyHooks }, %i },\n" %
+ (n.identifier.name, NamedConstructorName(n), methodLength(n)))
+
+ return fill(
+ """
+ const NativePropertyHooks sNamedConstructorNativePropertyHooks = {
+ nullptr,
+ nullptr,
+ nullptr,
+ { nullptr, nullptr },
+ prototypes::id::${name},
+ ${constructorID},
+ nullptr
+ };
+
+ static const NamedConstructor namedConstructors[] = {
+ $*{namedConstructors}
+ { nullptr, { nullptr, nullptr }, 0 }
+ };
+ """,
+ name=self.descriptor.name,
+ constructorID=constructorID,
+ namedConstructors=namedConstructors)
+
+
+class CGHasInstanceHook(CGAbstractStaticMethod):
+ def __init__(self, descriptor):
+ args = [Argument('JSContext*', 'cx'),
+ Argument('unsigned', 'argc'),
+ Argument('JS::Value*', 'vp')]
+ assert descriptor.interface.hasInterfaceObject()
+ assert NeedsGeneratedHasInstance(descriptor)
+ CGAbstractStaticMethod.__init__(self, descriptor, HASINSTANCE_HOOK_NAME,
+ 'bool', args)
+
+ def define(self):
+ return CGAbstractStaticMethod.define(self)
+
+ def definition_body(self):
+ return self.generate_code()
+
+ def generate_code(self):
+ header = dedent("""
+ JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
+ if (!args.get(0).isObject()) {
+ args.rval().setBoolean(false);
+ return true;
+ }
+
+ JS::Rooted<JSObject*> instance(cx, &args[0].toObject());
+ """)
+ if self.descriptor.interface.hasInterfacePrototypeObject():
+ return (
+ header +
+ fill(
+ """
+
+ static_assert(IsBaseOf<nsISupports, ${nativeType}>::value,
+ "HasInstance only works for nsISupports-based classes.");
+
+ bool ok = InterfaceHasInstance(cx, argc, vp);
+ if (!ok || args.rval().toBoolean()) {
+ return ok;
+ }
+
+ // FIXME Limit this to chrome by checking xpc::AccessCheck::isChrome(obj).
+ nsCOMPtr<nsISupports> native =
+ xpc::UnwrapReflectorToISupports(js::UncheckedUnwrap(instance, /* stopAtWindowProxy = */ false));
+ nsCOMPtr<nsIDOM${name}> qiResult = do_QueryInterface(native);
+ args.rval().setBoolean(!!qiResult);
+ return true;
+ """,
+ nativeType=self.descriptor.nativeType,
+ name=self.descriptor.interface.identifier.name))
+
+ hasInstanceCode = dedent("""
+
+ const DOMJSClass* domClass = GetDOMClass(js::UncheckedUnwrap(instance, /* stopAtWindowProxy = */ false));
+ if (!domClass) {
+ // Not a DOM object, so certainly not an instance of this interface
+ args.rval().setBoolean(false);
+ return true;
+ }
+ """)
+ if self.descriptor.interface.identifier.name == "ChromeWindow":
+ setRval = "args.rval().setBoolean(UnwrapDOMObject<nsGlobalWindow>(js::UncheckedUnwrap(instance, /* stopAtWindowProxy = */ false))->IsChromeWindow())"
+ else:
+ setRval = "args.rval().setBoolean(true)"
+ # Sort interaces implementing self by name so we get stable output.
+ for iface in sorted(self.descriptor.interface.interfacesImplementingSelf,
+ key=lambda iface: iface.identifier.name):
+ hasInstanceCode += fill(
+ """
+
+ if (domClass->mInterfaceChain[PrototypeTraits<prototypes::id::${name}>::Depth] == prototypes::id::${name}) {
+ ${setRval};
+ return true;
+ }
+ """,
+ name=iface.identifier.name,
+ setRval=setRval)
+ hasInstanceCode += ("args.rval().setBoolean(false);\n"
+ "return true;\n")
+ return header + hasInstanceCode
+
+
+def isChromeOnly(m):
+ return m.getExtendedAttribute("ChromeOnly")
+
+
+class MemberCondition:
+ """
+ An object representing the condition for a member to actually be
+ exposed. Any of the arguments can be None. If not
+ None, they should have the following types:
+
+ pref: The name of the preference.
+ func: The name of the function.
+ secureContext: A bool indicating whether a secure context is required.
+ nonExposedGlobals: A set of names of globals. Can be empty, in which case
+ it's treated the same way as None.
+ """
+ def __init__(self, pref=None, func=None, secureContext=False,
+ nonExposedGlobals=None):
+ assert pref is None or isinstance(pref, str)
+ assert func is None or isinstance(func, str)
+ assert isinstance(secureContext, bool)
+ assert nonExposedGlobals is None or isinstance(nonExposedGlobals, set)
+ self.pref = pref
+ self.secureContext = secureContext
+
+ def toFuncPtr(val):
+ if val is None:
+ return "nullptr"
+ return "&" + val
+ self.func = toFuncPtr(func)
+
+ if nonExposedGlobals:
+ # Nonempty set
+ self.nonExposedGlobals = " | ".join(
+ map(lambda g: "GlobalNames::%s" % g,
+ sorted(nonExposedGlobals)))
+ else:
+ self.nonExposedGlobals = "0"
+
+ def __eq__(self, other):
+ return (self.pref == other.pref and self.func == other.func and
+ self.secureContext == other.secureContext and
+ self.nonExposedGlobals == other.nonExposedGlobals)
+
+ def __ne__(self, other):
+ return not self.__eq__(other)
+
+ def hasDisablers(self):
+ return (self.pref is not None or
+ self.secureContext or
+ self.func != "nullptr" or
+ self.nonExposedGlobals != "0")
+
+
+class PropertyDefiner:
+ """
+ A common superclass for defining things on prototype objects.
+
+ Subclasses should implement generateArray to generate the actual arrays of
+ things we're defining. They should also set self.chrome to the list of
+ things only exposed to chrome and self.regular to the list of things exposed
+ to both chrome and web pages.
+ """
+ def __init__(self, descriptor, name):
+ self.descriptor = descriptor
+ self.name = name
+ # self.prefCacheData will store an array of (prefname, bool*)
+ # pairs for our bool var caches. generateArray will fill it
+ # in as needed.
+ self.prefCacheData = []
+
+ def hasChromeOnly(self):
+ return len(self.chrome) > 0
+
+ def hasNonChromeOnly(self):
+ return len(self.regular) > 0
+
+ def variableName(self, chrome):
+ if chrome:
+ if self.hasChromeOnly():
+ return "sChrome" + self.name
+ else:
+ if self.hasNonChromeOnly():
+ return "s" + self.name
+ return "nullptr"
+
+ def usedForXrays(self):
+ return self.descriptor.wantsXrays
+
+ def __str__(self):
+ # We only need to generate id arrays for things that will end
+ # up used via ResolveProperty or EnumerateProperties.
+ str = self.generateArray(self.regular, self.variableName(False),
+ self.usedForXrays())
+ if self.hasChromeOnly():
+ str += self.generateArray(self.chrome, self.variableName(True),
+ self.usedForXrays())
+ return str
+
+ @staticmethod
+ def getStringAttr(member, name):
+ attr = member.getExtendedAttribute(name)
+ if attr is None:
+ return None
+ # It's a list of strings
+ assert len(attr) == 1
+ assert attr[0] is not None
+ return attr[0]
+
+ @staticmethod
+ def getControllingCondition(interfaceMember, descriptor):
+ interface = descriptor.interface
+ nonExposureSet = interface.exposureSet - interfaceMember.exposureSet
+
+ return MemberCondition(
+ PropertyDefiner.getStringAttr(interfaceMember,
+ "Pref"),
+ PropertyDefiner.getStringAttr(interfaceMember,
+ "Func"),
+ interfaceMember.getExtendedAttribute("SecureContext") is not None,
+ nonExposureSet)
+
+ def generatePrefableArray(self, array, name, specFormatter, specTerminator,
+ specType, getCondition, getDataTuple, doIdArrays):
+ """
+ This method generates our various arrays.
+
+ array is an array of interface members as passed to generateArray
+
+ name is the name as passed to generateArray
+
+ specFormatter is a function that takes a single argument, a tuple,
+ and returns a string, a spec array entry
+
+ specTerminator is a terminator for the spec array (inserted every time
+ our controlling pref changes and at the end of the array)
+
+ specType is the actual typename of our spec
+
+ getCondition is a callback function that takes an array entry and
+ returns the corresponding MemberCondition.
+
+ getDataTuple is a callback function that takes an array entry and
+ returns a tuple suitable to be passed to specFormatter.
+ """
+
+ # We want to generate a single list of specs, but with specTerminator
+ # inserted at every point where the pref name controlling the member
+ # changes. That will make sure the order of the properties as exposed
+ # on the interface and interface prototype objects does not change when
+ # pref control is added to members while still allowing us to define all
+ # the members in the smallest number of JSAPI calls.
+ assert len(array) != 0
+ # So we won't put a specTerminator at the very front of the list:
+ lastCondition = getCondition(array[0], self.descriptor)
+
+ specs = []
+ disablers = []
+ prefableSpecs = []
+
+ disablersTemplate = dedent(
+ """
+ static PrefableDisablers %s_disablers%d = {
+ true, %s, %s, %s
+ };
+ """)
+ prefableWithDisablersTemplate = ' { &%s_disablers%d, &%s_specs[%d] }'
+ prefableWithoutDisablersTemplate = ' { nullptr, &%s_specs[%d] }'
+ prefCacheTemplate = '&%s[%d].disablers->enabled'
+
+ def switchToCondition(props, condition):
+ # Remember the info about where our pref-controlled
+ # booleans live.
+ if condition.pref is not None:
+ props.prefCacheData.append(
+ (condition.pref,
+ prefCacheTemplate % (name, len(prefableSpecs))))
+ # Set up pointers to the new sets of specs inside prefableSpecs
+ if condition.hasDisablers():
+ prefableSpecs.append(prefableWithDisablersTemplate %
+ (name, len(specs), name, len(specs)))
+ disablers.append(disablersTemplate %
+ (name, len(specs),
+ toStringBool(condition.secureContext),
+ condition.nonExposedGlobals,
+ condition.func))
+ else:
+ prefableSpecs.append(prefableWithoutDisablersTemplate %
+ (name, len(specs)))
+
+ switchToCondition(self, lastCondition)
+
+ for member in array:
+ curCondition = getCondition(member, self.descriptor)
+ if lastCondition != curCondition:
+ # Terminate previous list
+ specs.append(specTerminator)
+ # And switch to our new condition
+ switchToCondition(self, curCondition)
+ lastCondition = curCondition
+ # And the actual spec
+ specs.append(specFormatter(getDataTuple(member)))
+ specs.append(specTerminator)
+ prefableSpecs.append(" { nullptr, nullptr }")
+
+ specType = "const " + specType
+ arrays = fill(
+ """
+ static ${specType} ${name}_specs[] = {
+ ${specs}
+ };
+
+ ${disablers}
+ // Can't be const because the pref-enabled boolean needs to be writable
+ static Prefable<${specType}> ${name}[] = {
+ ${prefableSpecs}
+ };
+
+ """,
+ specType=specType,
+ name=name,
+ disablers='\n'.join(disablers),
+ specs=',\n'.join(specs),
+ prefableSpecs=',\n'.join(prefableSpecs))
+ if doIdArrays:
+ arrays += "static jsid %s_ids[%i];\n\n" % (name, len(specs))
+ return arrays
+
+
+# The length of a method is the minimum of the lengths of the
+# argument lists of all its overloads.
+def overloadLength(arguments):
+ i = len(arguments)
+ while i > 0 and arguments[i - 1].optional:
+ i -= 1
+ return i
+
+
+def methodLength(method):
+ signatures = method.signatures()
+ return min(overloadLength(arguments) for retType, arguments in signatures)
+
+
+def clearableCachedAttrs(descriptor):
+ return (m for m in descriptor.interface.members if
+ m.isAttr() and
+ # Constants should never need clearing!
+ m.dependsOn != "Nothing" and
+ m.slotIndices is not None)
+
+
+def MakeClearCachedValueNativeName(member):
+ return "ClearCached%sValue" % MakeNativeName(member.identifier.name)
+
+
+def MakeJSImplClearCachedValueNativeName(member):
+ return "_" + MakeClearCachedValueNativeName(member)
+
+
+def IDLToCIdentifier(name):
+ return name.replace("-", "_")
+
+
+class MethodDefiner(PropertyDefiner):
+ """
+ A class for defining methods on a prototype object.
+ """
+ def __init__(self, descriptor, name, static, unforgeable=False):
+ assert not (static and unforgeable)
+ PropertyDefiner.__init__(self, descriptor, name)
+
+ # FIXME https://bugzilla.mozilla.org/show_bug.cgi?id=772822
+ # We should be able to check for special operations without an
+ # identifier. For now we check if the name starts with __
+
+ # Ignore non-static methods for interfaces without a proto object
+ if descriptor.interface.hasInterfacePrototypeObject() or static:
+ methods = [m for m in descriptor.interface.members if
+ m.isMethod() and m.isStatic() == static and
+ MemberIsUnforgeable(m, descriptor) == unforgeable and
+ not m.isIdentifierLess()]
+ else:
+ methods = []
+ self.chrome = []
+ self.regular = []
+ for m in methods:
+ if m.identifier.name == 'queryInterface':
+ if m.isStatic():
+ raise TypeError("Legacy queryInterface member shouldn't be static")
+ signatures = m.signatures()
+
+ def argTypeIsIID(arg):
+ return arg.type.inner.isExternal() and arg.type.inner.identifier.name == 'IID'
+ if len(signatures) > 1 or len(signatures[0][1]) > 1 or not argTypeIsIID(signatures[0][1][0]):
+ raise TypeError("There should be only one queryInterface method with 1 argument of type IID")
+
+ # Make sure to not stick QueryInterface on abstract interfaces that
+ # have hasXPConnectImpls (like EventTarget). So only put it on
+ # interfaces that are concrete and all of whose ancestors are abstract.
+ def allAncestorsAbstract(iface):
+ if not iface.parent:
+ return True
+ desc = self.descriptor.getDescriptor(iface.parent.identifier.name)
+ if desc.concrete:
+ return False
+ return allAncestorsAbstract(iface.parent)
+ if (not self.descriptor.interface.hasInterfacePrototypeObject() or
+ not self.descriptor.concrete or
+ not allAncestorsAbstract(self.descriptor.interface)):
+ raise TypeError("QueryInterface is only supported on "
+ "interfaces that are concrete and all "
+ "of whose ancestors are abstract: " +
+ self.descriptor.name)
+ condition = "WantsQueryInterface<%s>::Enabled" % descriptor.nativeType
+ self.regular.append({
+ "name": 'QueryInterface',
+ "methodInfo": False,
+ "length": 1,
+ "flags": "0",
+ "condition": MemberCondition(func=condition)
+ })
+ continue
+
+ # Iterable methods should be enumerable, maplike/setlike methods
+ # should not.
+ isMaplikeOrSetlikeMethod = (m.isMaplikeOrSetlikeOrIterableMethod() and
+ (m.maplikeOrSetlikeOrIterable.isMaplike() or
+ m.maplikeOrSetlikeOrIterable.isSetlike()))
+ method = {
+ "name": m.identifier.name,
+ "methodInfo": not m.isStatic(),
+ "length": methodLength(m),
+ # Methods generated for a maplike/setlike declaration are not
+ # enumerable.
+ "flags": "JSPROP_ENUMERATE" if not isMaplikeOrSetlikeMethod else "0",
+ "condition": PropertyDefiner.getControllingCondition(m, descriptor),
+ "allowCrossOriginThis": m.getExtendedAttribute("CrossOriginCallable"),
+ "returnsPromise": m.returnsPromise(),
+ "hasIteratorAlias": "@@iterator" in m.aliases
+ }
+
+ if m.isStatic():
+ method["nativeName"] = CppKeywords.checkMethodName(IDLToCIdentifier(m.identifier.name))
+
+ if isChromeOnly(m):
+ self.chrome.append(method)
+ else:
+ self.regular.append(method)
+
+ # TODO: Once iterable is implemented, use tiebreak rules instead of
+ # failing. Also, may be more tiebreak rules to implement once spec bug
+ # is resolved.
+ # https://www.w3.org/Bugs/Public/show_bug.cgi?id=28592
+ def hasIterator(methods, regular):
+ return (any("@@iterator" in m.aliases for m in methods) or
+ any("@@iterator" == r["name"] for r in regular))
+
+ # Check whether we need to output an @@iterator due to having an indexed
+ # getter. We only do this while outputting non-static and
+ # non-unforgeable methods, since the @@iterator function will be
+ # neither.
+ if (not static and
+ not unforgeable and
+ descriptor.supportsIndexedProperties()):
+ if hasIterator(methods, self.regular):
+ raise TypeError("Cannot have indexed getter/attr on "
+ "interface %s with other members "
+ "that generate @@iterator, such as "
+ "maplike/setlike or aliased functions." %
+ self.descriptor.interface.identifier.name)
+ self.regular.append({
+ "name": "@@iterator",
+ "methodInfo": False,
+ "selfHostedName": "ArrayValues",
+ "length": 0,
+ "flags": "JSPROP_ENUMERATE",
+ "condition": MemberCondition()
+ })
+
+ if (static and
+ not unforgeable and
+ descriptor.interface.hasInterfaceObject() and
+ NeedsGeneratedHasInstance(descriptor)):
+ self.regular.append({
+ "name": "@@hasInstance",
+ "methodInfo": False,
+ "nativeName": HASINSTANCE_HOOK_NAME,
+ "length": 1,
+ # Flags match those of Function[Symbol.hasInstance]
+ "flags": "JSPROP_READONLY | JSPROP_PERMANENT",
+ "condition": MemberCondition()
+ })
+
+ # Generate the keys/values/entries aliases for value iterables.
+ maplikeOrSetlikeOrIterable = descriptor.interface.maplikeOrSetlikeOrIterable
+ if (not static and
+ not unforgeable and
+ maplikeOrSetlikeOrIterable and
+ maplikeOrSetlikeOrIterable.isIterable() and
+ maplikeOrSetlikeOrIterable.isValueIterator()):
+ # Add our keys/values/entries/forEach
+ self.regular.append({
+ "name": "keys",
+ "methodInfo": False,
+ "selfHostedName": "ArrayKeys",
+ "length": 0,
+ "flags": "JSPROP_ENUMERATE",
+ "condition": PropertyDefiner.getControllingCondition(m,
+ descriptor)
+ })
+ self.regular.append({
+ "name": "values",
+ "methodInfo": False,
+ "selfHostedName": "ArrayValues",
+ "length": 0,
+ "flags": "JSPROP_ENUMERATE",
+ "condition": PropertyDefiner.getControllingCondition(m,
+ descriptor)
+ })
+ self.regular.append({
+ "name": "entries",
+ "methodInfo": False,
+ "selfHostedName": "ArrayEntries",
+ "length": 0,
+ "flags": "JSPROP_ENUMERATE",
+ "condition": PropertyDefiner.getControllingCondition(m,
+ descriptor)
+ })
+ self.regular.append({
+ "name": "forEach",
+ "methodInfo": False,
+ "selfHostedName": "ArrayForEach",
+ "length": 1,
+ "flags": "JSPROP_ENUMERATE",
+ "condition": PropertyDefiner.getControllingCondition(m,
+ descriptor)
+ })
+
+ if not static:
+ stringifier = descriptor.operations['Stringifier']
+ if (stringifier and
+ unforgeable == MemberIsUnforgeable(stringifier, descriptor)):
+ toStringDesc = {
+ "name": "toString",
+ "nativeName": stringifier.identifier.name,
+ "length": 0,
+ "flags": "JSPROP_ENUMERATE",
+ "condition": PropertyDefiner.getControllingCondition(stringifier, descriptor)
+ }
+ if isChromeOnly(stringifier):
+ self.chrome.append(toStringDesc)
+ else:
+ self.regular.append(toStringDesc)
+ jsonifier = descriptor.operations['Jsonifier']
+ if (jsonifier and
+ unforgeable == MemberIsUnforgeable(jsonifier, descriptor)):
+ toJSONDesc = {
+ "name": "toJSON",
+ "nativeName": jsonifier.identifier.name,
+ "length": 0,
+ "flags": "JSPROP_ENUMERATE",
+ "condition": PropertyDefiner.getControllingCondition(jsonifier, descriptor)
+ }
+ if isChromeOnly(jsonifier):
+ self.chrome.append(toJSONDesc)
+ else:
+ self.regular.append(toJSONDesc)
+ if (unforgeable and
+ descriptor.interface.getExtendedAttribute("Unforgeable")):
+ # Synthesize our valueOf method
+ self.regular.append({
+ "name": 'valueOf',
+ "nativeName": "UnforgeableValueOf",
+ "methodInfo": False,
+ "length": 0,
+ "flags": "JSPROP_ENUMERATE", # readonly/permanent added
+ # automatically.
+ "condition": MemberCondition()
+ })
+
+ if descriptor.interface.isJSImplemented():
+ if static:
+ if descriptor.interface.hasInterfaceObject():
+ self.chrome.append({
+ "name": '_create',
+ "nativeName": ("%s::_Create" % descriptor.name),
+ "methodInfo": False,
+ "length": 2,
+ "flags": "0",
+ "condition": MemberCondition()
+ })
+ else:
+ for m in clearableCachedAttrs(descriptor):
+ attrName = MakeNativeName(m.identifier.name)
+ self.chrome.append({
+ "name": "_clearCached%sValue" % attrName,
+ "nativeName": MakeJSImplClearCachedValueNativeName(m),
+ "methodInfo": False,
+ "length": "0",
+ "flags": "0",
+ "condition": MemberCondition()
+ })
+
+ self.unforgeable = unforgeable
+
+ if static:
+ if not descriptor.interface.hasInterfaceObject():
+ # static methods go on the interface object
+ assert not self.hasChromeOnly() and not self.hasNonChromeOnly()
+ else:
+ if not descriptor.interface.hasInterfacePrototypeObject():
+ # non-static methods go on the interface prototype object
+ assert not self.hasChromeOnly() and not self.hasNonChromeOnly()
+
+ def generateArray(self, array, name, doIdArrays):
+ if len(array) == 0:
+ return ""
+
+ def condition(m, d):
+ return m["condition"]
+
+ def flags(m):
+ unforgeable = " | JSPROP_PERMANENT | JSPROP_READONLY" if self.unforgeable else ""
+ return m["flags"] + unforgeable
+
+ def specData(m):
+ if "selfHostedName" in m:
+ selfHostedName = '"%s"' % m["selfHostedName"]
+ assert not m.get("methodInfo", True)
+ accessor = "nullptr"
+ jitinfo = "nullptr"
+ else:
+ selfHostedName = "nullptr"
+ # When defining symbols, function name may not match symbol name
+ methodName = m.get("methodName", m["name"])
+ accessor = m.get("nativeName", IDLToCIdentifier(methodName))
+ if m.get("methodInfo", True):
+ # Cast this in case the methodInfo is a
+ # JSTypedMethodJitInfo.
+ jitinfo = ("reinterpret_cast<const JSJitInfo*>(&%s_methodinfo)" % accessor)
+ if m.get("allowCrossOriginThis", False):
+ if m.get("returnsPromise", False):
+ raise TypeError("%s returns a Promise but should "
+ "be allowed cross-origin?" %
+ accessor)
+ accessor = "genericCrossOriginMethod"
+ elif self.descriptor.needsSpecialGenericOps():
+ if m.get("returnsPromise", False):
+ accessor = "genericPromiseReturningMethod"
+ else:
+ accessor = "genericMethod"
+ elif m.get("returnsPromise", False):
+ accessor = "GenericPromiseReturningBindingMethod"
+ else:
+ accessor = "GenericBindingMethod"
+ else:
+ if m.get("returnsPromise", False):
+ jitinfo = "&%s_methodinfo" % accessor
+ accessor = "StaticMethodPromiseWrapper"
+ else:
+ jitinfo = "nullptr"
+
+ return (m["name"], accessor, jitinfo, m["length"], flags(m), selfHostedName)
+
+ def formatSpec(fields):
+ if fields[0].startswith("@@"):
+ fields = (fields[0][2:],) + fields[1:]
+ return ' JS_SYM_FNSPEC(%s, %s, %s, %s, %s, %s)' % fields
+ return ' JS_FNSPEC("%s", %s, %s, %s, %s, %s)' % fields
+
+ return self.generatePrefableArray(
+ array, name,
+ formatSpec,
+ ' JS_FS_END',
+ 'JSFunctionSpec',
+ condition, specData, doIdArrays)
+
+
+def IsCrossOriginWritable(attr, descriptor):
+ """
+ Return whether the IDLAttribute in question is cross-origin writable on the
+ interface represented by descriptor. This is needed to handle the fact that
+ some, but not all, interfaces implementing URLUtils want a cross-origin
+ writable .href.
+ """
+ crossOriginWritable = attr.getExtendedAttribute("CrossOriginWritable")
+ if not crossOriginWritable:
+ return False
+ if crossOriginWritable is True:
+ return True
+ assert (isinstance(crossOriginWritable, list) and
+ len(crossOriginWritable) == 1)
+ return crossOriginWritable[0] == descriptor.interface.identifier.name
+
+def isNonExposedNavigatorObjectGetter(attr, descriptor):
+ return (attr.navigatorObjectGetter and
+ not descriptor.getDescriptor(attr.type.inner.identifier.name).register)
+
+class AttrDefiner(PropertyDefiner):
+ def __init__(self, descriptor, name, static, unforgeable=False):
+ assert not (static and unforgeable)
+ PropertyDefiner.__init__(self, descriptor, name)
+ self.name = name
+ # Ignore non-static attributes for interfaces without a proto object
+ if descriptor.interface.hasInterfacePrototypeObject() or static:
+ attributes = [m for m in descriptor.interface.members if
+ m.isAttr() and m.isStatic() == static and
+ MemberIsUnforgeable(m, descriptor) == unforgeable and
+ not isNonExposedNavigatorObjectGetter(m, descriptor)]
+ else:
+ attributes = []
+ self.chrome = [m for m in attributes if isChromeOnly(m)]
+ self.regular = [m for m in attributes if not isChromeOnly(m)]
+ self.static = static
+ self.unforgeable = unforgeable
+
+ if static:
+ if not descriptor.interface.hasInterfaceObject():
+ # static attributes go on the interface object
+ assert not self.hasChromeOnly() and not self.hasNonChromeOnly()
+ else:
+ if not descriptor.interface.hasInterfacePrototypeObject():
+ # non-static attributes go on the interface prototype object
+ assert not self.hasChromeOnly() and not self.hasNonChromeOnly()
+
+ def generateArray(self, array, name, doIdArrays):
+ if len(array) == 0:
+ return ""
+
+ def flags(attr):
+ unforgeable = " | JSPROP_PERMANENT" if self.unforgeable else ""
+ # Attributes generated as part of a maplike/setlike declaration are
+ # not enumerable.
+ enumerable = " | JSPROP_ENUMERATE" if not attr.isMaplikeOrSetlikeAttr() else ""
+ return ("JSPROP_SHARED" + enumerable + unforgeable)
+
+ def getter(attr):
+ if self.static:
+ accessor = 'get_' + IDLToCIdentifier(attr.identifier.name)
+ jitinfo = "nullptr"
+ else:
+ if attr.hasLenientThis():
+ accessor = "genericLenientGetter"
+ elif attr.getExtendedAttribute("CrossOriginReadable"):
+ accessor = "genericCrossOriginGetter"
+ elif self.descriptor.needsSpecialGenericOps():
+ accessor = "genericGetter"
+ else:
+ accessor = "GenericBindingGetter"
+ jitinfo = ("&%s_getterinfo" %
+ IDLToCIdentifier(attr.identifier.name))
+ return "{ { %s, %s } }" % \
+ (accessor, jitinfo)
+
+ def setter(attr):
+ if (attr.readonly and
+ attr.getExtendedAttribute("PutForwards") is None and
+ attr.getExtendedAttribute("Replaceable") is None and
+ attr.getExtendedAttribute("LenientSetter") is None):
+ return "JSNATIVE_WRAPPER(nullptr)"
+ if self.static:
+ accessor = 'set_' + IDLToCIdentifier(attr.identifier.name)
+ jitinfo = "nullptr"
+ else:
+ if attr.hasLenientThis():
+ accessor = "genericLenientSetter"
+ elif IsCrossOriginWritable(attr, self.descriptor):
+ accessor = "genericCrossOriginSetter"
+ elif self.descriptor.needsSpecialGenericOps():
+ accessor = "genericSetter"
+ else:
+ accessor = "GenericBindingSetter"
+ jitinfo = "&%s_setterinfo" % IDLToCIdentifier(attr.identifier.name)
+ return "{ { %s, %s } }" % \
+ (accessor, jitinfo)
+
+ def specData(attr):
+ return (attr.identifier.name, flags(attr), getter(attr),
+ setter(attr))
+
+ return self.generatePrefableArray(
+ array, name,
+ lambda fields: ' { "%s", %s, { { %s, %s } } }' % fields,
+ ' JS_PS_END',
+ 'JSPropertySpec',
+ PropertyDefiner.getControllingCondition, specData, doIdArrays)
+
+
+class ConstDefiner(PropertyDefiner):
+ """
+ A class for definining constants on the interface object
+ """
+ def __init__(self, descriptor, name):
+ PropertyDefiner.__init__(self, descriptor, name)
+ self.name = name
+ constants = [m for m in descriptor.interface.members if m.isConst()]
+ self.chrome = [m for m in constants if isChromeOnly(m)]
+ self.regular = [m for m in constants if not isChromeOnly(m)]
+
+ def generateArray(self, array, name, doIdArrays):
+ if len(array) == 0:
+ return ""
+
+ def specData(const):
+ return (const.identifier.name,
+ convertConstIDLValueToJSVal(const.value))
+
+ return self.generatePrefableArray(
+ array, name,
+ lambda fields: ' { "%s", %s }' % fields,
+ ' { 0, JS::UndefinedValue() }',
+ 'ConstantSpec',
+ PropertyDefiner.getControllingCondition, specData, doIdArrays)
+
+
+class PropertyArrays():
+ def __init__(self, descriptor):
+ self.staticMethods = MethodDefiner(descriptor, "StaticMethods",
+ static=True)
+ self.staticAttrs = AttrDefiner(descriptor, "StaticAttributes",
+ static=True)
+ self.methods = MethodDefiner(descriptor, "Methods", static=False)
+ self.attrs = AttrDefiner(descriptor, "Attributes", static=False)
+ self.unforgeableMethods = MethodDefiner(descriptor, "UnforgeableMethods",
+ static=False, unforgeable=True)
+ self.unforgeableAttrs = AttrDefiner(descriptor, "UnforgeableAttributes",
+ static=False, unforgeable=True)
+ self.consts = ConstDefiner(descriptor, "Constants")
+
+ @staticmethod
+ def arrayNames():
+ return ["staticMethods", "staticAttrs", "methods", "attrs",
+ "unforgeableMethods", "unforgeableAttrs", "consts"]
+
+ def hasChromeOnly(self):
+ return any(getattr(self, a).hasChromeOnly() for a in self.arrayNames())
+
+ def hasNonChromeOnly(self):
+ return any(getattr(self, a).hasNonChromeOnly() for a in self.arrayNames())
+
+ def __str__(self):
+ define = ""
+ for array in self.arrayNames():
+ define += str(getattr(self, array))
+ return define
+
+
+class CGNativeProperties(CGList):
+ def __init__(self, descriptor, properties):
+ def generateNativeProperties(name, chrome):
+ def check(p):
+ return p.hasChromeOnly() if chrome else p.hasNonChromeOnly()
+
+ nativePropsInts = []
+ nativePropsTrios = []
+
+ iteratorAliasIndex = -1
+ for index, item in enumerate(properties.methods.regular):
+ if item.get("hasIteratorAlias"):
+ iteratorAliasIndex = index
+ break
+ nativePropsInts.append(CGGeneric(str(iteratorAliasIndex)))
+
+ offset = 0
+ for array in properties.arrayNames():
+ propertyArray = getattr(properties, array)
+ if check(propertyArray):
+ varName = propertyArray.variableName(chrome)
+ bitfields = "true, %d /* %s */" % (offset, varName)
+ offset += 1
+ nativePropsInts.append(CGGeneric(bitfields))
+
+ if propertyArray.usedForXrays():
+ ids = "%(name)s_ids"
+ else:
+ ids = "nullptr"
+ trio = "{ %(name)s, " + ids + ", %(name)s_specs }"
+ trio = trio % {'name': varName}
+ nativePropsTrios.append(CGGeneric(trio))
+ else:
+ bitfields = "false, 0"
+ nativePropsInts.append(CGGeneric(bitfields))
+
+ nativePropsTrios = \
+ [CGWrapper(CGIndenter(CGList(nativePropsTrios, ",\n")),
+ pre='{\n', post='\n}')]
+ nativeProps = nativePropsInts + nativePropsTrios
+ pre = ("static const NativePropertiesN<%d> %s = {\n" %
+ (offset, name))
+ return CGWrapper(CGIndenter(CGList(nativeProps, ",\n")),
+ pre=pre, post="\n};\n")
+
+ nativeProperties = []
+ if properties.hasNonChromeOnly():
+ nativeProperties.append(
+ generateNativeProperties("sNativeProperties", False))
+ if properties.hasChromeOnly():
+ nativeProperties.append(
+ generateNativeProperties("sChromeOnlyNativeProperties", True))
+
+ CGList.__init__(self, nativeProperties, "\n")
+
+ def declare(self):
+ return ""
+
+ def define(self):
+ return CGList.define(self)
+
+
+class CGJsonifyAttributesMethod(CGAbstractMethod):
+ """
+ Generate the JsonifyAttributes method for an interface descriptor
+ """
+ def __init__(self, descriptor):
+ args = [Argument('JSContext*', 'aCx'),
+ Argument('JS::Handle<JSObject*>', 'obj'),
+ Argument('%s*' % descriptor.nativeType, 'self'),
+ Argument('JS::Rooted<JSObject*>&', 'aResult')]
+ CGAbstractMethod.__init__(self, descriptor, 'JsonifyAttributes', 'bool', args)
+
+ def definition_body(self):
+ ret = ''
+ interface = self.descriptor.interface
+ for m in interface.members:
+ if m.isAttr() and not m.isStatic() and m.type.isSerializable():
+ ret += fill(
+ """
+ { // scope for "temp"
+ JS::Rooted<JS::Value> temp(aCx);
+ if (!get_${name}(aCx, obj, self, JSJitGetterCallArgs(&temp))) {
+ return false;
+ }
+ if (!JS_DefineProperty(aCx, aResult, "${name}", temp, JSPROP_ENUMERATE)) {
+ return false;
+ }
+ }
+ """,
+ name=IDLToCIdentifier(m.identifier.name))
+ ret += 'return true;\n'
+ return ret
+
+
+class CGCreateInterfaceObjectsMethod(CGAbstractMethod):
+ """
+ Generate the CreateInterfaceObjects method for an interface descriptor.
+
+ properties should be a PropertyArrays instance.
+ """
+ def __init__(self, descriptor, properties, haveUnscopables):
+ args = [Argument('JSContext*', 'aCx'),
+ Argument('JS::Handle<JSObject*>', 'aGlobal'),
+ Argument('ProtoAndIfaceCache&', 'aProtoAndIfaceCache'),
+ Argument('bool', 'aDefineOnGlobal')]
+ CGAbstractMethod.__init__(self, descriptor, 'CreateInterfaceObjects', 'void', args)
+ self.properties = properties
+ self.haveUnscopables = haveUnscopables
+
+ def definition_body(self):
+ (protoGetter, protoHandleGetter) = InterfacePrototypeObjectProtoGetter(self.descriptor)
+ if protoHandleGetter is None:
+ parentProtoType = "Rooted"
+ getParentProto = "aCx, " + protoGetter
+ else:
+ parentProtoType = "Handle"
+ getParentProto = protoHandleGetter
+ getParentProto = getParentProto + "(aCx)"
+
+ (protoGetter, protoHandleGetter) = InterfaceObjectProtoGetter(self.descriptor)
+ if protoHandleGetter is None:
+ getConstructorProto = "aCx, " + protoGetter
+ constructorProtoType = "Rooted"
+ else:
+ getConstructorProto = protoHandleGetter
+ constructorProtoType = "Handle"
+ getConstructorProto += "(aCx)"
+
+ needInterfaceObject = self.descriptor.interface.hasInterfaceObject()
+ needInterfacePrototypeObject = self.descriptor.interface.hasInterfacePrototypeObject()
+
+ # if we don't need to create anything, why are we generating this?
+ assert needInterfaceObject or needInterfacePrototypeObject
+
+ getParentProto = fill(
+ """
+ JS::${type}<JSObject*> parentProto(${getParentProto});
+ if (!parentProto) {
+ return;
+ }
+ """,
+ type=parentProtoType,
+ getParentProto=getParentProto)
+
+ getConstructorProto = fill(
+ """
+ JS::${type}<JSObject*> constructorProto(${getConstructorProto});
+ if (!constructorProto) {
+ return;
+ }
+ """,
+ type=constructorProtoType,
+ getConstructorProto=getConstructorProto)
+
+ idsToInit = []
+ # There is no need to init any IDs in bindings that don't want Xrays.
+ if self.descriptor.wantsXrays:
+ for var in self.properties.arrayNames():
+ props = getattr(self.properties, var)
+ # We only have non-chrome ids to init if we have no chrome ids.
+ if props.hasChromeOnly():
+ idsToInit.append(props.variableName(True))
+ if props.hasNonChromeOnly():
+ idsToInit.append(props.variableName(False))
+ if len(idsToInit) > 0:
+ initIdCalls = ["!InitIds(aCx, %s, %s_ids)" % (varname, varname)
+ for varname in idsToInit]
+ idsInitedFlag = CGGeneric("static bool sIdsInited = false;\n")
+ setFlag = CGGeneric("sIdsInited = true;\n")
+ initIdConditionals = [CGIfWrapper(CGGeneric("return;\n"), call)
+ for call in initIdCalls]
+ initIds = CGList([idsInitedFlag,
+ CGIfWrapper(CGList(initIdConditionals + [setFlag]),
+ "!sIdsInited && NS_IsMainThread()")])
+ else:
+ initIds = None
+
+ prefCacheData = []
+ for var in self.properties.arrayNames():
+ props = getattr(self.properties, var)
+ prefCacheData.extend(props.prefCacheData)
+ if len(prefCacheData) != 0:
+ prefCacheData = [
+ CGGeneric('Preferences::AddBoolVarCache(%s, "%s");\n' % (ptr, pref))
+ for pref, ptr in prefCacheData]
+ prefCache = CGWrapper(CGIndenter(CGList(prefCacheData)),
+ pre=("static bool sPrefCachesInited = false;\n"
+ "if (!sPrefCachesInited && NS_IsMainThread()) {\n"
+ " sPrefCachesInited = true;\n"),
+ post="}\n")
+ else:
+ prefCache = None
+
+ if self.descriptor.interface.ctor():
+ constructArgs = methodLength(self.descriptor.interface.ctor())
+ else:
+ constructArgs = 0
+ if len(self.descriptor.interface.namedConstructors) > 0:
+ namedConstructors = "namedConstructors"
+ else:
+ namedConstructors = "nullptr"
+
+ if needInterfacePrototypeObject:
+ protoClass = "&sPrototypeClass.mBase"
+ protoCache = "&aProtoAndIfaceCache.EntrySlotOrCreate(prototypes::id::%s)" % self.descriptor.name
+ parentProto = "parentProto"
+ getParentProto = CGGeneric(getParentProto)
+ else:
+ protoClass = "nullptr"
+ protoCache = "nullptr"
+ parentProto = "nullptr"
+ getParentProto = None
+
+ if needInterfaceObject:
+ interfaceClass = "&sInterfaceObjectClass.mBase"
+ interfaceCache = "&aProtoAndIfaceCache.EntrySlotOrCreate(constructors::id::%s)" % self.descriptor.name
+ getConstructorProto = CGGeneric(getConstructorProto)
+ constructorProto = "constructorProto"
+ else:
+ # We don't have slots to store the named constructors.
+ assert len(self.descriptor.interface.namedConstructors) == 0
+ interfaceClass = "nullptr"
+ interfaceCache = "nullptr"
+ getConstructorProto = None
+ constructorProto = "nullptr"
+
+ isGlobal = self.descriptor.isGlobal() is not None
+ if self.properties.hasNonChromeOnly():
+ properties = "sNativeProperties.Upcast()"
+ else:
+ properties = "nullptr"
+ if self.properties.hasChromeOnly():
+ chromeProperties = "nsContentUtils::ThreadsafeIsCallerChrome() ? sChromeOnlyNativeProperties.Upcast() : nullptr"
+ else:
+ chromeProperties = "nullptr"
+
+ call = fill(
+ """
+ JS::Heap<JSObject*>* protoCache = ${protoCache};
+ JS::Heap<JSObject*>* interfaceCache = ${interfaceCache};
+ dom::CreateInterfaceObjects(aCx, aGlobal, ${parentProto},
+ ${protoClass}, protoCache,
+ ${constructorProto}, ${interfaceClass}, ${constructArgs}, ${namedConstructors},
+ interfaceCache,
+ ${properties},
+ ${chromeProperties},
+ ${name}, aDefineOnGlobal,
+ ${unscopableNames},
+ ${isGlobal});
+ """,
+ protoClass=protoClass,
+ parentProto=parentProto,
+ protoCache=protoCache,
+ constructorProto=constructorProto,
+ interfaceClass=interfaceClass,
+ constructArgs=constructArgs,
+ namedConstructors=namedConstructors,
+ interfaceCache=interfaceCache,
+ properties=properties,
+ chromeProperties=chromeProperties,
+ name='"' + self.descriptor.interface.identifier.name + '"' if needInterfaceObject else "nullptr",
+ unscopableNames="unscopableNames" if self.haveUnscopables else "nullptr",
+ isGlobal=toStringBool(isGlobal))
+
+ # If we fail after here, we must clear interface and prototype caches
+ # using this code: intermediate failure must not expose the interface in
+ # partially-constructed state. Note that every case after here needs an
+ # interface prototype object.
+ failureCode = dedent(
+ """
+ *protoCache = nullptr;
+ if (interfaceCache) {
+ *interfaceCache = nullptr;
+ }
+ return;
+ """)
+
+ aliasedMembers = [m for m in self.descriptor.interface.members if m.isMethod() and m.aliases]
+ if aliasedMembers:
+ assert needInterfacePrototypeObject
+
+ def defineAlias(alias):
+ if alias == "@@iterator":
+ symbolJSID = "SYMBOL_TO_JSID(JS::GetWellKnownSymbol(aCx, JS::SymbolCode::iterator))"
+ getSymbolJSID = CGGeneric(fill("JS::Rooted<jsid> iteratorId(aCx, ${symbolJSID});",
+ symbolJSID=symbolJSID))
+ defineFn = "JS_DefinePropertyById"
+ prop = "iteratorId"
+ elif alias.startswith("@@"):
+ raise TypeError("Can't handle any well-known Symbol other than @@iterator")
+ else:
+ getSymbolJSID = None
+ defineFn = "JS_DefineProperty"
+ prop = '"%s"' % alias
+ return CGList([
+ getSymbolJSID,
+ # XXX If we ever create non-enumerable properties that can
+ # be aliased, we should consider making the aliases
+ # match the enumerability of the property being aliased.
+ CGGeneric(fill(
+ """
+ if (!${defineFn}(aCx, proto, ${prop}, aliasedVal, JSPROP_ENUMERATE)) {
+ $*{failureCode}
+ }
+ """,
+ defineFn=defineFn,
+ prop=prop,
+ failureCode=failureCode))
+ ], "\n")
+
+ def defineAliasesFor(m):
+ return CGList([
+ CGGeneric(fill(
+ """
+ if (!JS_GetProperty(aCx, proto, \"${prop}\", &aliasedVal)) {
+ $*{failureCode}
+ }
+ """,
+ failureCode=failureCode,
+ prop=m.identifier.name))
+ ] + [defineAlias(alias) for alias in sorted(m.aliases)])
+
+ defineAliases = CGList([
+ CGGeneric(fill("""
+ // Set up aliases on the interface prototype object we just created.
+ JS::Handle<JSObject*> proto = GetProtoObjectHandle(aCx);
+ if (!proto) {
+ $*{failureCode}
+ }
+
+ """,
+ failureCode=failureCode)),
+ CGGeneric("JS::Rooted<JS::Value> aliasedVal(aCx);\n\n")
+ ] + [defineAliasesFor(m) for m in sorted(aliasedMembers)])
+ else:
+ defineAliases = None
+
+ # Globals handle unforgeables directly in Wrap() instead of
+ # via a holder.
+ if self.descriptor.hasUnforgeableMembers and not self.descriptor.isGlobal():
+ assert needInterfacePrototypeObject
+
+ # We want to use the same JSClass and prototype as the object we'll
+ # end up defining the unforgeable properties on in the end, so that
+ # we can use JS_InitializePropertiesFromCompatibleNativeObject to do
+ # a fast copy. In the case of proxies that's null, because the
+ # expando object is a vanilla object, but in the case of other DOM
+ # objects it's whatever our class is.
+ if self.descriptor.proxy:
+ holderClass = "nullptr"
+ holderProto = "nullptr"
+ else:
+ holderClass = "sClass.ToJSClass()"
+ holderProto = "*protoCache"
+ createUnforgeableHolder = CGGeneric(fill(
+ """
+ JS::Rooted<JSObject*> unforgeableHolder(aCx);
+ {
+ JS::Rooted<JSObject*> holderProto(aCx, ${holderProto});
+ unforgeableHolder = JS_NewObjectWithoutMetadata(aCx, ${holderClass}, holderProto);
+ if (!unforgeableHolder) {
+ $*{failureCode}
+ }
+ }
+ """,
+ holderProto=holderProto,
+ holderClass=holderClass,
+ failureCode=failureCode))
+ defineUnforgeables = InitUnforgeablePropertiesOnHolder(self.descriptor,
+ self.properties,
+ failureCode)
+ createUnforgeableHolder = CGList(
+ [createUnforgeableHolder, defineUnforgeables])
+
+ installUnforgeableHolder = CGGeneric(dedent(
+ """
+ if (*protoCache) {
+ js::SetReservedSlot(*protoCache, DOM_INTERFACE_PROTO_SLOTS_BASE,
+ JS::ObjectValue(*unforgeableHolder));
+ }
+ """))
+
+ unforgeableHolderSetup = CGList(
+ [createUnforgeableHolder, installUnforgeableHolder], "\n")
+ else:
+ unforgeableHolderSetup = None
+
+ if self.descriptor.name == "Promise":
+ speciesSetup = CGGeneric(fill(
+ """
+ #ifndef SPIDERMONKEY_PROMISE
+ JS::Rooted<JSObject*> promiseConstructor(aCx, *interfaceCache);
+ JS::Rooted<jsid> species(aCx,
+ SYMBOL_TO_JSID(JS::GetWellKnownSymbol(aCx, JS::SymbolCode::species)));
+ if (!JS_DefinePropertyById(aCx, promiseConstructor, species, JS::UndefinedHandleValue,
+ JSPROP_SHARED, Promise::PromiseSpecies, nullptr)) {
+ $*{failureCode}
+ }
+ #endif // SPIDERMONKEY_PROMISE
+ """,
+ failureCode=failureCode))
+ else:
+ speciesSetup = None
+
+ if (self.descriptor.interface.isOnGlobalProtoChain() and
+ needInterfacePrototypeObject):
+ makeProtoPrototypeImmutable = CGGeneric(fill(
+ """
+ if (*${protoCache}) {
+ bool succeeded;
+ JS::Handle<JSObject*> prot = GetProtoObjectHandle(aCx);
+ if (!JS_SetImmutablePrototype(aCx, prot, &succeeded)) {
+ $*{failureCode}
+ }
+
+ MOZ_ASSERT(succeeded,
+ "making a fresh prototype object's [[Prototype]] "
+ "immutable can internally fail, but it should "
+ "never be unsuccessful");
+ }
+ """,
+ protoCache=protoCache,
+ failureCode=failureCode))
+ else:
+ makeProtoPrototypeImmutable = None
+
+ return CGList(
+ [getParentProto, getConstructorProto, initIds,
+ prefCache, CGGeneric(call), defineAliases, unforgeableHolderSetup,
+ speciesSetup, makeProtoPrototypeImmutable],
+ "\n").define()
+
+
+class CGGetPerInterfaceObject(CGAbstractMethod):
+ """
+ A method for getting a per-interface object (a prototype object or interface
+ constructor object).
+ """
+ def __init__(self, descriptor, name, idPrefix="", extraArgs=[]):
+ args = [Argument('JSContext*', 'aCx')] + extraArgs
+ CGAbstractMethod.__init__(self, descriptor, name,
+ 'JS::Handle<JSObject*>', args)
+ self.id = idPrefix + "id::" + self.descriptor.name
+
+ def definition_body(self):
+ return fill(
+ """
+ /* Make sure our global is sane. Hopefully we can remove this sometime */
+ JSObject* global = JS::CurrentGlobalOrNull(aCx);
+ if (!(js::GetObjectClass(global)->flags & JSCLASS_DOM_GLOBAL)) {
+ return nullptr;
+ }
+
+ /* Check to see whether the interface objects are already installed */
+ ProtoAndIfaceCache& protoAndIfaceCache = *GetProtoAndIfaceCache(global);
+ if (!protoAndIfaceCache.EntrySlotIfExists(${id})) {
+ JS::Rooted<JSObject*> rootedGlobal(aCx, global);
+ CreateInterfaceObjects(aCx, rootedGlobal, protoAndIfaceCache, aDefineOnGlobal);
+ }
+
+ /*
+ * The object might _still_ be null, but that's OK.
+ *
+ * Calling fromMarkedLocation() is safe because protoAndIfaceCache is
+ * traced by TraceProtoAndIfaceCache() and its contents are never
+ * changed after they have been set.
+ *
+ * Calling address() avoids the read read barrier that does gray
+ * unmarking, but it's not possible for the object to be gray here.
+ */
+
+ const JS::Heap<JSObject*>& entrySlot = protoAndIfaceCache.EntrySlotMustExist(${id});
+ MOZ_ASSERT_IF(entrySlot, !JS::ObjectIsMarkedGray(entrySlot));
+ return JS::Handle<JSObject*>::fromMarkedLocation(entrySlot.address());
+ """,
+ id=self.id)
+
+
+class CGGetProtoObjectHandleMethod(CGGetPerInterfaceObject):
+ """
+ A method for getting the interface prototype object.
+ """
+ def __init__(self, descriptor):
+ CGGetPerInterfaceObject.__init__(self, descriptor, "GetProtoObjectHandle",
+ "prototypes::")
+
+ def definition_body(self):
+ return dedent("""
+ /* Get the interface prototype object for this class. This will create the
+ object as needed. */
+ bool aDefineOnGlobal = true;
+
+ """) + CGGetPerInterfaceObject.definition_body(self)
+
+
+class CGGetProtoObjectMethod(CGAbstractMethod):
+ """
+ A method for getting the interface prototype object.
+ """
+ def __init__(self, descriptor):
+ CGAbstractMethod.__init__(
+ self, descriptor, "GetProtoObject", "JSObject*",
+ [Argument('JSContext*', 'aCx')])
+
+ def definition_body(self):
+ return "return GetProtoObjectHandle(aCx);\n"
+
+
+class CGGetConstructorObjectHandleMethod(CGGetPerInterfaceObject):
+ """
+ A method for getting the interface constructor object.
+ """
+ def __init__(self, descriptor):
+ CGGetPerInterfaceObject.__init__(
+ self, descriptor, "GetConstructorObjectHandle",
+ "constructors::",
+ extraArgs=[Argument("bool", "aDefineOnGlobal", "true")])
+
+ def definition_body(self):
+ return dedent("""
+ /* Get the interface object for this class. This will create the object as
+ needed. */
+
+ """) + CGGetPerInterfaceObject.definition_body(self)
+
+
+class CGGetConstructorObjectMethod(CGAbstractMethod):
+ """
+ A method for getting the interface constructor object.
+ """
+ def __init__(self, descriptor):
+ CGAbstractMethod.__init__(
+ self, descriptor, "GetConstructorObject", "JSObject*",
+ [Argument('JSContext*', 'aCx')])
+
+ def definition_body(self):
+ return "return GetConstructorObjectHandle(aCx);\n"
+
+
+class CGGetNamedPropertiesObjectMethod(CGAbstractStaticMethod):
+ def __init__(self, descriptor):
+ args = [Argument('JSContext*', 'aCx')]
+ CGAbstractStaticMethod.__init__(self, descriptor,
+ 'GetNamedPropertiesObject',
+ 'JSObject*', args)
+
+ def definition_body(self):
+ parentProtoName = self.descriptor.parentPrototypeName
+ if parentProtoName is None:
+ getParentProto = ""
+ parentProto = "nullptr"
+ else:
+ getParentProto = fill(
+ """
+ JS::Rooted<JSObject*> parentProto(aCx, ${parent}::GetProtoObjectHandle(aCx));
+ if (!parentProto) {
+ return nullptr;
+ }
+ """,
+ parent=toBindingNamespace(parentProtoName))
+ parentProto = "parentProto"
+ return fill(
+ """
+ /* Make sure our global is sane. Hopefully we can remove this sometime */
+ JSObject* global = JS::CurrentGlobalOrNull(aCx);
+ if (!(js::GetObjectClass(global)->flags & JSCLASS_DOM_GLOBAL)) {
+ return nullptr;
+ }
+
+ /* Check to see whether the named properties object has already been created */
+ ProtoAndIfaceCache& protoAndIfaceCache = *GetProtoAndIfaceCache(global);
+
+ JS::Heap<JSObject*>& namedPropertiesObject = protoAndIfaceCache.EntrySlotOrCreate(namedpropertiesobjects::id::${ifaceName});
+ if (!namedPropertiesObject) {
+ $*{getParentProto}
+ namedPropertiesObject = ${nativeType}::CreateNamedPropertiesObject(aCx, ${parentProto});
+ DebugOnly<const DOMIfaceAndProtoJSClass*> clasp =
+ DOMIfaceAndProtoJSClass::FromJSClass(js::GetObjectClass(namedPropertiesObject));
+ MOZ_ASSERT(clasp->mType == eNamedPropertiesObject,
+ "Expected ${nativeType}::CreateNamedPropertiesObject to return a named properties object");
+ MOZ_ASSERT(clasp->mNativeHooks,
+ "The named properties object for ${nativeType} should have NativePropertyHooks.");
+ MOZ_ASSERT(clasp->mNativeHooks->mResolveOwnProperty,
+ "Don't know how to resolve the properties of the named properties object for ${nativeType}.");
+ MOZ_ASSERT(clasp->mNativeHooks->mEnumerateOwnProperties,
+ "Don't know how to enumerate the properties of the named properties object for ${nativeType}.");
+ }
+ return namedPropertiesObject.get();
+ """,
+ getParentProto=getParentProto,
+ ifaceName=self.descriptor.name,
+ parentProto=parentProto,
+ nativeType=self.descriptor.nativeType)
+
+
+class CGDefineDOMInterfaceMethod(CGAbstractMethod):
+ """
+ A method for resolve hooks to try to lazily define the interface object for
+ a given interface.
+ """
+ def __init__(self, descriptor):
+ args = [Argument('JSContext*', 'aCx'),
+ Argument('JS::Handle<JSObject*>', 'aGlobal'),
+ Argument('JS::Handle<jsid>', 'id'),
+ Argument('bool', 'aDefineOnGlobal')]
+ CGAbstractMethod.__init__(self, descriptor, 'DefineDOMInterface', 'JSObject*', args)
+
+ def definition_body(self):
+ if len(self.descriptor.interface.namedConstructors) > 0:
+ getConstructor = dedent("""
+ JSObject* interfaceObject = GetConstructorObjectHandle(aCx, aDefineOnGlobal);
+ if (!interfaceObject) {
+ return nullptr;
+ }
+ for (unsigned slot = DOM_INTERFACE_SLOTS_BASE; slot < JSCLASS_RESERVED_SLOTS(&sInterfaceObjectClass.mBase); ++slot) {
+ JSObject* constructor = &js::GetReservedSlot(interfaceObject, slot).toObject();
+ if (JS_GetFunctionId(JS_GetObjectFunction(constructor)) == JSID_TO_STRING(id)) {
+ return constructor;
+ }
+ }
+ return interfaceObject;
+ """)
+ else:
+ getConstructor = "return GetConstructorObjectHandle(aCx, aDefineOnGlobal);\n"
+ return getConstructor
+
+
+def getConditionList(idlobj, cxName, objName):
+ """
+ Get the list of conditions for idlobj (to be used in "is this enabled"
+ checks). This will be returned as a CGList with " &&\n" as the separator,
+ for readability.
+
+ objName is the name of the object that we're working with, because some of
+ our test functions want that.
+ """
+ conditions = []
+ pref = idlobj.getExtendedAttribute("Pref")
+ if pref:
+ assert isinstance(pref, list) and len(pref) == 1
+ conditions.append('Preferences::GetBool("%s")' % pref[0])
+ if idlobj.getExtendedAttribute("ChromeOnly"):
+ conditions.append("nsContentUtils::ThreadsafeIsCallerChrome()")
+ func = idlobj.getExtendedAttribute("Func")
+ if func:
+ assert isinstance(func, list) and len(func) == 1
+ conditions.append("%s(%s, %s)" % (func[0], cxName, objName))
+ if idlobj.getExtendedAttribute("SecureContext"):
+ conditions.append("mozilla::dom::IsSecureContextOrObjectIsFromSecureContext(%s, %s)" % (cxName, objName))
+
+ return CGList((CGGeneric(cond) for cond in conditions), " &&\n")
+
+
+class CGConstructorEnabled(CGAbstractMethod):
+ """
+ A method for testing whether we should be exposing this interface
+ object or navigator property. This can perform various tests
+ depending on what conditions are specified on the interface.
+ """
+ def __init__(self, descriptor):
+ CGAbstractMethod.__init__(self, descriptor,
+ 'ConstructorEnabled', 'bool',
+ [Argument("JSContext*", "aCx"),
+ Argument("JS::Handle<JSObject*>", "aObj")])
+
+ def definition_body(self):
+ body = CGList([], "\n")
+
+ iface = self.descriptor.interface
+
+ if not iface.isExposedOnMainThread():
+ exposedInWindowCheck = dedent(
+ """
+ MOZ_ASSERT(!NS_IsMainThread(), "Why did we even get called?");
+ """)
+ body.append(CGGeneric(exposedInWindowCheck))
+
+ if iface.isExposedInSomeButNotAllWorkers():
+ workerGlobals = sorted(iface.getWorkerExposureSet())
+ workerCondition = CGList((CGGeneric('strcmp(name, "%s")' % workerGlobal)
+ for workerGlobal in workerGlobals), " && ")
+ exposedInWorkerCheck = fill(
+ """
+ const char* name = js::GetObjectClass(aObj)->name;
+ if (${workerCondition}) {
+ return false;
+ }
+ """, workerCondition=workerCondition.define())
+ exposedInWorkerCheck = CGGeneric(exposedInWorkerCheck)
+ if iface.isExposedOnMainThread():
+ exposedInWorkerCheck = CGIfWrapper(exposedInWorkerCheck,
+ "!NS_IsMainThread()")
+ body.append(exposedInWorkerCheck)
+
+ conditions = getConditionList(iface, "aCx", "aObj")
+
+ # We should really have some conditions
+ assert len(body) or len(conditions)
+
+ conditionsWrapper = ""
+ if len(conditions):
+ conditionsWrapper = CGWrapper(conditions,
+ pre="return ",
+ post=";\n",
+ reindent=True)
+ else:
+ conditionsWrapper = CGGeneric("return true;\n")
+
+ body.append(conditionsWrapper)
+ return body.define()
+
+
+def CreateBindingJSObject(descriptor, properties):
+ objDecl = "BindingJSObjectCreator<%s> creator(aCx);\n" % descriptor.nativeType
+
+ # We don't always need to root obj, but there are a variety
+ # of cases where we do, so for simplicity, just always root it.
+ if descriptor.proxy:
+ create = dedent(
+ """
+ creator.CreateProxyObject(aCx, &sClass.mBase, DOMProxyHandler::getInstance(),
+ proto, aObject, aReflector);
+ if (!aReflector) {
+ return false;
+ }
+
+ """)
+ if descriptor.interface.getExtendedAttribute('OverrideBuiltins'):
+ create += dedent("""
+ js::SetProxyExtra(aReflector, JSPROXYSLOT_EXPANDO,
+ JS::PrivateValue(&aObject->mExpandoAndGeneration));
+
+ """)
+ else:
+ create = dedent(
+ """
+ creator.CreateObject(aCx, sClass.ToJSClass(), proto, aObject, aReflector);
+ if (!aReflector) {
+ return false;
+ }
+ """)
+ return objDecl + create
+
+
+def InitUnforgeablePropertiesOnHolder(descriptor, properties, failureCode,
+ holderName="unforgeableHolder"):
+ """
+ Define the unforgeable properties on the unforgeable holder for
+ the interface represented by descriptor.
+
+ properties is a PropertyArrays instance.
+
+ """
+ assert (properties.unforgeableAttrs.hasNonChromeOnly() or
+ properties.unforgeableAttrs.hasChromeOnly() or
+ properties.unforgeableMethods.hasNonChromeOnly() or
+ properties.unforgeableMethods.hasChromeOnly())
+
+ unforgeables = []
+
+ defineUnforgeableAttrs = fill(
+ """
+ if (!DefineUnforgeableAttributes(aCx, ${holderName}, %s)) {
+ $*{failureCode}
+ }
+ """,
+ failureCode=failureCode,
+ holderName=holderName)
+ defineUnforgeableMethods = fill(
+ """
+ if (!DefineUnforgeableMethods(aCx, ${holderName}, %s)) {
+ $*{failureCode}
+ }
+ """,
+ failureCode=failureCode,
+ holderName=holderName)
+
+ unforgeableMembers = [
+ (defineUnforgeableAttrs, properties.unforgeableAttrs),
+ (defineUnforgeableMethods, properties.unforgeableMethods)
+ ]
+ for (template, array) in unforgeableMembers:
+ if array.hasNonChromeOnly():
+ unforgeables.append(CGGeneric(template % array.variableName(False)))
+ if array.hasChromeOnly():
+ unforgeables.append(
+ CGIfWrapper(CGGeneric(template % array.variableName(True)),
+ "nsContentUtils::ThreadsafeIsCallerChrome()"))
+
+ if descriptor.interface.getExtendedAttribute("Unforgeable"):
+ # We do our undefined toJSON and toPrimitive here, not as a regular
+ # property because we don't have a concept of value props anywhere in
+ # IDL.
+ unforgeables.append(CGGeneric(fill(
+ """
+ JS::RootedId toPrimitive(aCx,
+ SYMBOL_TO_JSID(JS::GetWellKnownSymbol(aCx, JS::SymbolCode::toPrimitive)));
+ if (!JS_DefinePropertyById(aCx, ${holderName}, toPrimitive,
+ JS::UndefinedHandleValue,
+ JSPROP_READONLY | JSPROP_PERMANENT) ||
+ !JS_DefineProperty(aCx, ${holderName}, "toJSON",
+ JS::UndefinedHandleValue,
+ JSPROP_READONLY | JSPROP_ENUMERATE | JSPROP_PERMANENT)) {
+ $*{failureCode}
+ }
+ """,
+ failureCode=failureCode,
+ holderName=holderName)))
+
+ return CGWrapper(CGList(unforgeables), pre="\n")
+
+
+def CopyUnforgeablePropertiesToInstance(descriptor, failureCode):
+ """
+ Copy the unforgeable properties from the unforgeable holder for
+ this interface to the instance object we have.
+ """
+ assert not descriptor.isGlobal();
+
+ if not descriptor.hasUnforgeableMembers:
+ return ""
+
+ copyCode = [
+ CGGeneric(dedent(
+ """
+ // Important: do unforgeable property setup after we have handed
+ // over ownership of the C++ object to obj as needed, so that if
+ // we fail and it ends up GCed it won't have problems in the
+ // finalizer trying to drop its ownership of the C++ object.
+ """))
+ ]
+
+ # For proxies, we want to define on the expando object, not directly on the
+ # reflector, so we can make sure we don't get confused by named getters.
+ if descriptor.proxy:
+ copyCode.append(CGGeneric(fill(
+ """
+ JS::Rooted<JSObject*> expando(aCx,
+ DOMProxyHandler::EnsureExpandoObject(aCx, aReflector));
+ if (!expando) {
+ $*{failureCode}
+ }
+ """,
+ failureCode=failureCode)))
+ obj = "expando"
+ else:
+ obj = "aReflector"
+
+ copyCode.append(CGGeneric(fill(
+ """
+ JS::Rooted<JSObject*> unforgeableHolder(aCx,
+ &js::GetReservedSlot(canonicalProto, DOM_INTERFACE_PROTO_SLOTS_BASE).toObject());
+ if (!JS_InitializePropertiesFromCompatibleNativeObject(aCx, ${obj}, unforgeableHolder)) {
+ $*{failureCode}
+ }
+ """,
+ obj=obj,
+ failureCode=failureCode)))
+
+ return CGWrapper(CGList(copyCode), pre="\n").define()
+
+
+def AssertInheritanceChain(descriptor):
+ asserts = ""
+ iface = descriptor.interface
+ while iface:
+ desc = descriptor.getDescriptor(iface.identifier.name)
+ asserts += (
+ "MOZ_ASSERT(static_cast<%s*>(aObject) == \n"
+ " reinterpret_cast<%s*>(aObject),\n"
+ " \"Multiple inheritance for %s is broken.\");\n" %
+ (desc.nativeType, desc.nativeType, desc.nativeType))
+ iface = iface.parent
+ asserts += "MOZ_ASSERT(ToSupportsIsCorrect(aObject));\n"
+ return asserts
+
+
+def InitMemberSlots(descriptor, failureCode):
+ """
+ Initialize member slots on our JS object if we're supposed to have some.
+
+ Note that this is called after the SetWrapper() call in the
+ wrapperCache case, since that can affect how our getters behave
+ and we plan to invoke them here. So if we fail, we need to
+ ClearWrapper.
+ """
+ if not descriptor.interface.hasMembersInSlots():
+ return ""
+ return fill(
+ """
+ if (!UpdateMemberSlots(aCx, aReflector, aObject)) {
+ $*{failureCode}
+ }
+ """,
+ failureCode=failureCode)
+
+
+def SetImmutablePrototype(descriptor, failureCode):
+ if not descriptor.hasNonOrdinaryGetPrototypeOf():
+ return ""
+
+ return fill(
+ """
+ bool succeeded;
+ if (!JS_SetImmutablePrototype(aCx, aReflector, &succeeded)) {
+ ${failureCode}
+ }
+ MOZ_ASSERT(succeeded,
+ "Making a fresh reflector instance have an immutable "
+ "prototype can internally fail, but it should never be "
+ "unsuccessful");
+ """,
+ failureCode=failureCode)
+
+
+def DeclareProto():
+ """
+ Declare the canonicalProto and proto we have for our wrapping operation.
+ """
+ return dedent(
+ """
+ JS::Handle<JSObject*> canonicalProto = GetProtoObjectHandle(aCx);
+ if (!canonicalProto) {
+ return false;
+ }
+ JS::Rooted<JSObject*> proto(aCx);
+ if (aGivenProto) {
+ proto = aGivenProto;
+ // Unfortunately, while aGivenProto was in the compartment of aCx
+ // coming in, we changed compartments to that of "parent" so may need
+ // to wrap the proto here.
+ if (js::GetContextCompartment(aCx) != js::GetObjectCompartment(proto)) {
+ if (!JS_WrapObject(aCx, &proto)) {
+ return false;
+ }
+ }
+ } else {
+ proto = canonicalProto;
+ }
+ """)
+
+
+class CGWrapWithCacheMethod(CGAbstractMethod):
+ """
+ Create a wrapper JSObject for a given native that implements nsWrapperCache.
+
+ properties should be a PropertyArrays instance.
+ """
+ def __init__(self, descriptor, properties):
+ assert descriptor.interface.hasInterfacePrototypeObject()
+ args = [Argument('JSContext*', 'aCx'),
+ Argument(descriptor.nativeType + '*', 'aObject'),
+ Argument('nsWrapperCache*', 'aCache'),
+ Argument('JS::Handle<JSObject*>', 'aGivenProto'),
+ Argument('JS::MutableHandle<JSObject*>', 'aReflector')]
+ CGAbstractMethod.__init__(self, descriptor, 'Wrap', 'bool', args)
+ self.properties = properties
+
+ def definition_body(self):
+ if self.descriptor.proxy:
+ preserveWrapper = dedent(
+ """
+ // For DOM proxies, the only reliable way to preserve the wrapper
+ // is to force creation of the expando object.
+ JS::Rooted<JSObject*> unused(aCx,
+ DOMProxyHandler::EnsureExpandoObject(aCx, aReflector));
+ """)
+ else:
+ preserveWrapper = "PreserveWrapper(aObject);\n"
+
+ failureCode = dedent(
+ """
+ aCache->ReleaseWrapper(aObject);
+ aCache->ClearWrapper();
+ return false;
+ """)
+
+ return fill(
+ """
+ $*{assertInheritance}
+ MOZ_ASSERT(!aCache->GetWrapper(),
+ "You should probably not be using Wrap() directly; use "
+ "GetOrCreateDOMReflector instead");
+
+ MOZ_ASSERT(ToSupportsIsOnPrimaryInheritanceChain(aObject, aCache),
+ "nsISupports must be on our primary inheritance chain");
+
+ JS::Rooted<JSObject*> global(aCx, FindAssociatedGlobal(aCx, aObject->GetParentObject()));
+ if (!global) {
+ return false;
+ }
+ MOZ_ASSERT(JS_IsGlobalObject(global));
+ MOZ_ASSERT(!JS::ObjectIsMarkedGray(global));
+
+ // That might have ended up wrapping us already, due to the wonders
+ // of XBL. Check for that, and bail out as needed.
+ aReflector.set(aCache->GetWrapper());
+ if (aReflector) {
+ #ifdef DEBUG
+ binding_detail::AssertReflectorHasGivenProto(aCx, aReflector, aGivenProto);
+ #endif // DEBUG
+ return true;
+ }
+
+ JSAutoCompartment ac(aCx, global);
+ $*{declareProto}
+
+ $*{createObject}
+
+ aCache->SetWrapper(aReflector);
+ $*{unforgeable}
+ $*{slots}
+ $*{setImmutablePrototype}
+ creator.InitializationSucceeded();
+
+ MOZ_ASSERT(aCache->GetWrapperPreserveColor() &&
+ aCache->GetWrapperPreserveColor() == aReflector);
+ // If proto != canonicalProto, we have to preserve our wrapper;
+ // otherwise we won't be able to properly recreate it later, since
+ // we won't know what proto to use. Note that we don't check
+ // aGivenProto here, since it's entirely possible (and even
+ // somewhat common) to have a non-null aGivenProto which is the
+ // same as canonicalProto.
+ if (proto != canonicalProto) {
+ $*{preserveWrapper}
+ }
+
+ return true;
+ """,
+ assertInheritance=AssertInheritanceChain(self.descriptor),
+ declareProto=DeclareProto(),
+ createObject=CreateBindingJSObject(self.descriptor, self.properties),
+ unforgeable=CopyUnforgeablePropertiesToInstance(self.descriptor,
+ failureCode),
+ slots=InitMemberSlots(self.descriptor, failureCode),
+ setImmutablePrototype=SetImmutablePrototype(self.descriptor,
+ failureCode),
+ preserveWrapper=preserveWrapper)
+
+
+class CGWrapMethod(CGAbstractMethod):
+ def __init__(self, descriptor):
+ # XXX can we wrap if we don't have an interface prototype object?
+ assert descriptor.interface.hasInterfacePrototypeObject()
+ args = [Argument('JSContext*', 'aCx'),
+ Argument('T*', 'aObject'),
+ Argument('JS::Handle<JSObject*>', 'aGivenProto')]
+ CGAbstractMethod.__init__(self, descriptor, 'Wrap', 'JSObject*', args,
+ inline=True, templateArgs=["class T"])
+
+ def definition_body(self):
+ return dedent("""
+ JS::Rooted<JSObject*> reflector(aCx);
+ return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
+ """)
+
+
+class CGWrapNonWrapperCacheMethod(CGAbstractMethod):
+ """
+ Create a wrapper JSObject for a given native that does not implement
+ nsWrapperCache.
+
+ properties should be a PropertyArrays instance.
+ """
+ def __init__(self, descriptor, properties):
+ # XXX can we wrap if we don't have an interface prototype object?
+ assert descriptor.interface.hasInterfacePrototypeObject()
+ args = [Argument('JSContext*', 'aCx'),
+ Argument(descriptor.nativeType + '*', 'aObject'),
+ Argument('JS::Handle<JSObject*>', 'aGivenProto'),
+ Argument('JS::MutableHandle<JSObject*>', 'aReflector')]
+ CGAbstractMethod.__init__(self, descriptor, 'Wrap', 'bool', args)
+ self.properties = properties
+
+ def definition_body(self):
+ failureCode = "return false;\n"
+
+ return fill(
+ """
+ $*{assertions}
+
+ JS::Rooted<JSObject*> global(aCx, JS::CurrentGlobalOrNull(aCx));
+ $*{declareProto}
+
+ $*{createObject}
+
+ $*{unforgeable}
+
+ $*{slots}
+
+ $*{setImmutablePrototype}
+ creator.InitializationSucceeded();
+ return true;
+ """,
+ assertions=AssertInheritanceChain(self.descriptor),
+ declareProto=DeclareProto(),
+ createObject=CreateBindingJSObject(self.descriptor, self.properties),
+ unforgeable=CopyUnforgeablePropertiesToInstance(self.descriptor,
+ failureCode),
+ slots=InitMemberSlots(self.descriptor, failureCode),
+ setImmutablePrototype=SetImmutablePrototype(self.descriptor,
+ failureCode))
+
+
+class CGWrapGlobalMethod(CGAbstractMethod):
+ """
+ Create a wrapper JSObject for a global. The global must implement
+ nsWrapperCache.
+
+ properties should be a PropertyArrays instance.
+ """
+ def __init__(self, descriptor, properties):
+ assert descriptor.interface.hasInterfacePrototypeObject()
+ args = [Argument('JSContext*', 'aCx'),
+ Argument(descriptor.nativeType + '*', 'aObject'),
+ Argument('nsWrapperCache*', 'aCache'),
+ Argument('JS::CompartmentOptions&', 'aOptions'),
+ Argument('JSPrincipals*', 'aPrincipal'),
+ Argument('bool', 'aInitStandardClasses'),
+ Argument('JS::MutableHandle<JSObject*>', 'aReflector')]
+ CGAbstractMethod.__init__(self, descriptor, 'Wrap', 'bool', args)
+ self.descriptor = descriptor
+ self.properties = properties
+
+ def definition_body(self):
+ if self.properties.hasNonChromeOnly():
+ properties = "sNativeProperties.Upcast()"
+ else:
+ properties = "nullptr"
+ if self.properties.hasChromeOnly():
+ chromeProperties = "nsContentUtils::ThreadsafeIsCallerChrome() ? sChromeOnlyNativeProperties.Upcast() : nullptr"
+ else:
+ chromeProperties = "nullptr"
+
+ failureCode = dedent(
+ """
+ aCache->ReleaseWrapper(aObject);
+ aCache->ClearWrapper();
+ return false;
+ """);
+
+ if self.descriptor.hasUnforgeableMembers:
+ unforgeable = InitUnforgeablePropertiesOnHolder(
+ self.descriptor, self.properties, failureCode,
+ "aReflector").define();
+ else:
+ unforgeable = ""
+
+ return fill(
+ """
+ $*{assertions}
+ MOZ_ASSERT(ToSupportsIsOnPrimaryInheritanceChain(aObject, aCache),
+ "nsISupports must be on our primary inheritance chain");
+
+ if (!CreateGlobal<${nativeType}, GetProtoObjectHandle>(aCx,
+ aObject,
+ aCache,
+ sClass.ToJSClass(),
+ aOptions,
+ aPrincipal,
+ aInitStandardClasses,
+ aReflector)) {
+ $*{failureCode}
+ }
+
+ // aReflector is a new global, so has a new compartment. Enter it
+ // before doing anything with it.
+ JSAutoCompartment ac(aCx, aReflector);
+
+ if (!DefineProperties(aCx, aReflector, ${properties}, ${chromeProperties})) {
+ $*{failureCode}
+ }
+ $*{unforgeable}
+
+ $*{slots}
+
+ return true;
+ """,
+ assertions=AssertInheritanceChain(self.descriptor),
+ nativeType=self.descriptor.nativeType,
+ properties=properties,
+ chromeProperties=chromeProperties,
+ failureCode=failureCode,
+ unforgeable=unforgeable,
+ slots=InitMemberSlots(self.descriptor, failureCode))
+
+
+class CGUpdateMemberSlotsMethod(CGAbstractStaticMethod):
+ def __init__(self, descriptor):
+ args = [Argument('JSContext*', 'aCx'),
+ Argument('JS::Handle<JSObject*>', 'aWrapper'),
+ Argument(descriptor.nativeType + '*', 'aObject')]
+ CGAbstractStaticMethod.__init__(self, descriptor, 'UpdateMemberSlots', 'bool', args)
+
+ def definition_body(self):
+ body = ("JS::Rooted<JS::Value> temp(aCx);\n"
+ "JSJitGetterCallArgs args(&temp);\n")
+ for m in self.descriptor.interface.members:
+ if m.isAttr() and m.getExtendedAttribute("StoreInSlot"):
+ # Skip doing this for the "window" and "self" attributes on the
+ # Window interface, because those can't be gotten safely until
+ # we have hooked it up correctly to the outer window. The
+ # window code handles doing the get itself.
+ if (self.descriptor.interface.identifier.name == "Window" and
+ (m.identifier.name == "window" or m.identifier.name == "self")):
+ continue
+ body += fill(
+ """
+
+ if (!get_${member}(aCx, aWrapper, aObject, args)) {
+ return false;
+ }
+ // Getter handled setting our reserved slots
+ """,
+ member=m.identifier.name)
+
+ body += "\nreturn true;\n"
+ return body
+
+
+class CGClearCachedValueMethod(CGAbstractMethod):
+ def __init__(self, descriptor, member):
+ self.member = member
+ # If we're StoreInSlot, we'll need to call the getter
+ if member.getExtendedAttribute("StoreInSlot"):
+ args = [Argument('JSContext*', 'aCx')]
+ returnType = 'bool'
+ else:
+ args = []
+ returnType = 'void'
+ args.append(Argument(descriptor.nativeType + '*', 'aObject'))
+ name = MakeClearCachedValueNativeName(member)
+ CGAbstractMethod.__init__(self, descriptor, name, returnType, args)
+
+ def definition_body(self):
+ slotIndex = memberReservedSlot(self.member, self.descriptor)
+ if self.member.getExtendedAttribute("StoreInSlot"):
+ # We have to root things and save the old value in case
+ # regetting fails, so we can restore it.
+ declObj = "JS::Rooted<JSObject*> obj(aCx);\n"
+ noopRetval = " true"
+ saveMember = (
+ "JS::Rooted<JS::Value> oldValue(aCx, js::GetReservedSlot(obj, %s));\n" %
+ slotIndex)
+ regetMember = fill(
+ """
+ JS::Rooted<JS::Value> temp(aCx);
+ JSJitGetterCallArgs args(&temp);
+ JSAutoCompartment ac(aCx, obj);
+ if (!get_${name}(aCx, obj, aObject, args)) {
+ js::SetReservedSlot(obj, ${slotIndex}, oldValue);
+ return false;
+ }
+ return true;
+ """,
+ name=self.member.identifier.name,
+ slotIndex=slotIndex)
+ else:
+ declObj = "JSObject* obj;\n"
+ noopRetval = ""
+ saveMember = ""
+ regetMember = ""
+
+ if self.descriptor.wantsXrays:
+ clearXrayExpandoSlots = fill(
+ """
+ xpc::ClearXrayExpandoSlots(obj, ${xraySlotIndex});
+ """,
+ xraySlotIndex=memberXrayExpandoReservedSlot(self.member,
+ self.descriptor))
+ else :
+ clearXrayExpandoSlots = ""
+
+ return fill(
+ """
+ $*{declObj}
+ obj = aObject->GetWrapper();
+ if (!obj) {
+ return${noopRetval};
+ }
+ $*{saveMember}
+ js::SetReservedSlot(obj, ${slotIndex}, JS::UndefinedValue());
+ $*{clearXrayExpandoSlots}
+ $*{regetMember}
+ """,
+ declObj=declObj,
+ noopRetval=noopRetval,
+ saveMember=saveMember,
+ slotIndex=slotIndex,
+ clearXrayExpandoSlots=clearXrayExpandoSlots,
+ regetMember=regetMember)
+
+
+class CGIsPermittedMethod(CGAbstractMethod):
+ """
+ crossOriginGetters/Setters/Methods are sets of names of the relevant members.
+ """
+ def __init__(self, descriptor, crossOriginGetters, crossOriginSetters,
+ crossOriginMethods):
+ self.crossOriginGetters = crossOriginGetters
+ self.crossOriginSetters = crossOriginSetters
+ self.crossOriginMethods = crossOriginMethods
+ args = [Argument("JSFlatString*", "prop"),
+ Argument("char16_t", "propFirstChar"),
+ Argument("bool", "set")]
+ CGAbstractMethod.__init__(self, descriptor, "IsPermitted", "bool", args,
+ inline=True)
+
+ def definition_body(self):
+ allNames = self.crossOriginGetters | self.crossOriginSetters | self.crossOriginMethods
+ readwrite = self.crossOriginGetters & self.crossOriginSetters
+ readonly = (self.crossOriginGetters - self.crossOriginSetters) | self.crossOriginMethods
+ writeonly = self.crossOriginSetters - self.crossOriginGetters
+ cases = {}
+ for name in sorted(allNames):
+ cond = 'JS_FlatStringEqualsAscii(prop, "%s")' % name
+ if name in readonly:
+ cond = "!set && %s" % cond
+ elif name in writeonly:
+ cond = "set && %s" % cond
+ else:
+ assert name in readwrite
+ firstLetter = name[0]
+ case = cases.get(firstLetter, CGList([]))
+ case.append(CGGeneric("if (%s) {\n"
+ " return true;\n"
+ "}\n" % cond))
+ cases[firstLetter] = case
+ caseList = []
+ for firstLetter in sorted(cases.keys()):
+ caseList.append(CGCase("'%s'" % firstLetter, cases[firstLetter]))
+ switch = CGSwitch("propFirstChar", caseList)
+ return switch.define() + "\nreturn false;\n"
+
+
+class CGCycleCollectionTraverseForOwningUnionMethod(CGAbstractMethod):
+ """
+ ImplCycleCollectionUnlink for owning union type.
+ """
+ def __init__(self, type):
+ self.type = type
+ args = [Argument("nsCycleCollectionTraversalCallback&", "aCallback"),
+ Argument("%s&" % CGUnionStruct.unionTypeName(type, True), "aUnion"),
+ Argument("const char*", "aName"),
+ Argument("uint32_t", "aFlags", "0")]
+ CGAbstractMethod.__init__(self, None, "ImplCycleCollectionTraverse", "void", args)
+
+ def deps(self):
+ return self.type.getDeps()
+
+ def definition_body(self):
+ memberNames = [getUnionMemberName(t)
+ for t in self.type.flatMemberTypes
+ if idlTypeNeedsCycleCollection(t)]
+ assert memberNames
+
+ conditionTemplate = 'aUnion.Is%s()'
+ functionCallTemplate = 'ImplCycleCollectionTraverse(aCallback, aUnion.GetAs%s(), "m%s", aFlags);\n'
+
+ ifStaments = (CGIfWrapper(CGGeneric(functionCallTemplate % (m, m)),
+ conditionTemplate % m)
+ for m in memberNames)
+
+ return CGElseChain(ifStaments).define()
+
+
+class CGCycleCollectionUnlinkForOwningUnionMethod(CGAbstractMethod):
+ """
+ ImplCycleCollectionUnlink for owning union type.
+ """
+ def __init__(self, type):
+ self.type = type
+ args = [Argument("%s&" % CGUnionStruct.unionTypeName(type, True), "aUnion")]
+ CGAbstractMethod.__init__(self, None, "ImplCycleCollectionUnlink", "void", args)
+
+ def deps(self):
+ return self.type.getDeps()
+
+ def definition_body(self):
+ return "aUnion.Uninit();\n"
+
+
+builtinNames = {
+ IDLType.Tags.bool: 'bool',
+ IDLType.Tags.int8: 'int8_t',
+ IDLType.Tags.int16: 'int16_t',
+ IDLType.Tags.int32: 'int32_t',
+ IDLType.Tags.int64: 'int64_t',
+ IDLType.Tags.uint8: 'uint8_t',
+ IDLType.Tags.uint16: 'uint16_t',
+ IDLType.Tags.uint32: 'uint32_t',
+ IDLType.Tags.uint64: 'uint64_t',
+ IDLType.Tags.unrestricted_float: 'float',
+ IDLType.Tags.float: 'float',
+ IDLType.Tags.unrestricted_double: 'double',
+ IDLType.Tags.double: 'double'
+}
+
+numericSuffixes = {
+ IDLType.Tags.int8: '',
+ IDLType.Tags.uint8: '',
+ IDLType.Tags.int16: '',
+ IDLType.Tags.uint16: '',
+ IDLType.Tags.int32: '',
+ IDLType.Tags.uint32: 'U',
+ IDLType.Tags.int64: 'LL',
+ IDLType.Tags.uint64: 'ULL',
+ IDLType.Tags.unrestricted_float: 'F',
+ IDLType.Tags.float: 'F',
+ IDLType.Tags.unrestricted_double: '',
+ IDLType.Tags.double: ''
+}
+
+
+def numericValue(t, v):
+ if (t == IDLType.Tags.unrestricted_double or
+ t == IDLType.Tags.unrestricted_float):
+ typeName = builtinNames[t]
+ if v == float("inf"):
+ return "mozilla::PositiveInfinity<%s>()" % typeName
+ if v == float("-inf"):
+ return "mozilla::NegativeInfinity<%s>()" % typeName
+ if math.isnan(v):
+ return "mozilla::UnspecifiedNaN<%s>()" % typeName
+ return "%s%s" % (v, numericSuffixes[t])
+
+
+class CastableObjectUnwrapper():
+ """
+ A class for unwrapping an object stored in a JS Value (or
+ MutableHandle<Value> or Handle<Value>) named by the "source" and
+ "mutableSource" arguments based on the passed-in descriptor and storing it
+ in a variable called by the name in the "target" argument. The "source"
+ argument should be able to produce a Value or Handle<Value>; the
+ "mutableSource" argument should be able to produce a MutableHandle<Value>
+
+ codeOnFailure is the code to run if unwrapping fails.
+
+ If isCallbackReturnValue is "JSImpl" and our descriptor is also
+ JS-implemented, fall back to just creating the right object if what we
+ have isn't one already.
+
+ If allowCrossOriginObj is True, then we'll first do an
+ UncheckedUnwrap and then operate on the result.
+ """
+ def __init__(self, descriptor, source, mutableSource, target, codeOnFailure,
+ exceptionCode=None, isCallbackReturnValue=False,
+ allowCrossOriginObj=False):
+ self.substitution = {
+ "type": descriptor.nativeType,
+ "protoID": "prototypes::id::" + descriptor.name,
+ "target": target,
+ "codeOnFailure": codeOnFailure,
+ }
+ # Supporting both the "cross origin object" case and the "has
+ # XPConnect impls" case at the same time is a pain, so let's
+ # not do that. That allows us to assume that our source is
+ # always a Handle or MutableHandle.
+ if allowCrossOriginObj and descriptor.hasXPConnectImpls:
+ raise TypeError("Interface %s both allows a cross-origin 'this' "
+ "and has XPConnect impls. We don't support that" %
+ descriptor.name)
+ if allowCrossOriginObj:
+ self.substitution["uncheckedObjDecl"] = fill(
+ """
+ JS::Rooted<JSObject*> maybeUncheckedObj(cx, &${source}.toObject());
+ """,
+ source=source)
+ self.substitution["uncheckedObjGet"] = fill(
+ """
+ if (xpc::WrapperFactory::IsXrayWrapper(maybeUncheckedObj)) {
+ maybeUncheckedObj = js::UncheckedUnwrap(maybeUncheckedObj);
+ } else {
+ maybeUncheckedObj = js::CheckedUnwrap(maybeUncheckedObj);
+ if (!maybeUncheckedObj) {
+ $*{codeOnFailure}
+ }
+ }
+ """,
+ codeOnFailure=(codeOnFailure % { 'securityError': 'true'}))
+ self.substitution["source"] = "maybeUncheckedObj"
+ self.substitution["mutableSource"] = "&maybeUncheckedObj"
+ # No need to set up xpconnectUnwrap, since it won't be
+ # used in the allowCrossOriginObj case.
+ else:
+ self.substitution["uncheckedObjDecl"] = ""
+ self.substitution["uncheckedObjGet"] = ""
+ self.substitution["source"] = source
+ self.substitution["mutableSource"] = mutableSource
+ xpconnectUnwrap = (
+ "nsresult rv = UnwrapXPConnect<${type}>(cx, ${mutableSource}, getter_AddRefs(objPtr));\n")
+
+ if descriptor.hasXPConnectImpls:
+ self.substitution["codeOnFailure"] = string.Template(
+ "RefPtr<${type}> objPtr;\n" +
+ xpconnectUnwrap +
+ "if (NS_FAILED(rv)) {\n"
+ "${indentedCodeOnFailure}"
+ "}\n"
+ "// We should have an object\n"
+ "MOZ_ASSERT(objPtr);\n"
+ "${target} = objPtr;\n"
+ ).substitute(self.substitution,
+ indentedCodeOnFailure=indent(codeOnFailure))
+ elif (isCallbackReturnValue == "JSImpl" and
+ descriptor.interface.isJSImplemented()):
+ exceptionCode = exceptionCode or codeOnFailure
+ self.substitution["codeOnFailure"] = fill(
+ """
+ // Be careful to not wrap random DOM objects here, even if
+ // they're wrapped in opaque security wrappers for some reason.
+ // XXXbz Wish we could check for a JS-implemented object
+ // that already has a content reflection...
+ if (!IsDOMObject(js::UncheckedUnwrap(&${source}.toObject()))) {
+ nsCOMPtr<nsIGlobalObject> contentGlobal;
+ if (!GetContentGlobalForJSImplementedObject(cx, Callback(), getter_AddRefs(contentGlobal))) {
+ $*{exceptionCode}
+ }
+ JS::Rooted<JSObject*> jsImplSourceObj(cx, &${source}.toObject());
+ ${target} = new ${type}(jsImplSourceObj, contentGlobal);
+ } else {
+ $*{codeOnFailure}
+ }
+ """,
+ exceptionCode=exceptionCode,
+ **self.substitution)
+ else:
+ self.substitution["codeOnFailure"] = codeOnFailure
+
+ def __str__(self):
+ substitution = self.substitution.copy()
+ substitution["codeOnFailure"] %= {
+ 'securityError': 'rv == NS_ERROR_XPC_SECURITY_MANAGER_VETO'
+ }
+ return fill(
+ """
+ $*{uncheckedObjDecl}
+ {
+ $*{uncheckedObjGet}
+ nsresult rv = UnwrapObject<${protoID}, ${type}>(${mutableSource}, ${target});
+ if (NS_FAILED(rv)) {
+ $*{codeOnFailure}
+ }
+ }
+ """,
+ **substitution)
+
+
+class FailureFatalCastableObjectUnwrapper(CastableObjectUnwrapper):
+ """
+ As CastableObjectUnwrapper, but defaulting to throwing if unwrapping fails
+ """
+ def __init__(self, descriptor, source, mutableSource, target, exceptionCode,
+ isCallbackReturnValue, sourceDescription):
+ CastableObjectUnwrapper.__init__(
+ self, descriptor, source, mutableSource, target,
+ 'ThrowErrorMessage(cx, MSG_DOES_NOT_IMPLEMENT_INTERFACE, "%s", "%s");\n'
+ '%s' % (sourceDescription, descriptor.interface.identifier.name,
+ exceptionCode),
+ exceptionCode,
+ isCallbackReturnValue)
+
+
+class CGCallbackTempRoot(CGGeneric):
+ def __init__(self, name):
+ define = dedent("""
+ { // Scope for tempRoot
+ JS::Rooted<JSObject*> tempRoot(cx, &${val}.toObject());
+ ${declName} = new %s(cx, tempRoot, mozilla::dom::GetIncumbentGlobal());
+ }
+ """) % name
+ CGGeneric.__init__(self, define=define)
+
+
+def getCallbackConversionInfo(type, idlObject, isMember, isCallbackReturnValue,
+ isOptional):
+ """
+ Returns a tuple containing the declType, declArgs, and basic
+ conversion for the given callback type, with the given callback
+ idl object in the given context (isMember/isCallbackReturnValue/isOptional).
+ """
+ name = idlObject.identifier.name
+
+ # We can't use fast callbacks if isOptional because then we get an
+ # Optional<RootedCallback> thing, which is not transparent to consumers.
+ useFastCallback = (not isMember and not isCallbackReturnValue and
+ not isOptional)
+ if useFastCallback:
+ name = "binding_detail::Fast%s" % name
+
+ if type.nullable() or isCallbackReturnValue:
+ declType = CGGeneric("RefPtr<%s>" % name)
+ else:
+ declType = CGGeneric("OwningNonNull<%s>" % name)
+
+ if useFastCallback:
+ declType = CGTemplatedType("RootedCallback", declType)
+ declArgs = "cx"
+ else:
+ declArgs = None
+
+ conversion = indent(CGCallbackTempRoot(name).define())
+ return (declType, declArgs, conversion)
+
+
+class JSToNativeConversionInfo():
+ """
+ An object representing information about a JS-to-native conversion.
+ """
+ def __init__(self, template, declType=None, holderType=None,
+ dealWithOptional=False, declArgs=None,
+ holderArgs=None):
+ """
+ template: A string representing the conversion code. This will have
+ template substitution performed on it as follows:
+
+ ${val} is a handle to the JS::Value in question
+ ${maybeMutableVal} May be a mutable handle to the JS::Value in
+ question. This is only OK to use if ${val} is
+ known to not be undefined.
+ ${holderName} replaced by the holder's name, if any
+ ${declName} replaced by the declaration's name
+ ${haveValue} replaced by an expression that evaluates to a boolean
+ for whether we have a JS::Value. Only used when
+ defaultValue is not None or when True is passed for
+ checkForValue to instantiateJSToNativeConversion.
+ ${passedToJSImpl} replaced by an expression that evaluates to a boolean
+ for whether this value is being passed to a JS-
+ implemented interface.
+
+ declType: A CGThing representing the native C++ type we're converting
+ to. This is allowed to be None if the conversion code is
+ supposed to be used as-is.
+
+ holderType: A CGThing representing the type of a "holder" which will
+ hold a possible reference to the C++ thing whose type we
+ returned in declType, or None if no such holder is needed.
+
+ dealWithOptional: A boolean indicating whether the caller has to do
+ optional-argument handling. This should only be set
+ to true if the JS-to-native conversion is being done
+ for an optional argument or dictionary member with no
+ default value and if the returned template expects
+ both declType and holderType to be wrapped in
+ Optional<>, with ${declName} and ${holderName}
+ adjusted to point to the Value() of the Optional, and
+ Construct() calls to be made on the Optional<>s as
+ needed.
+
+ declArgs: If not None, the arguments to pass to the ${declName}
+ constructor. These will have template substitution performed
+ on them so you can use things like ${val}. This is a
+ single string, not a list of strings.
+
+ holderArgs: If not None, the arguments to pass to the ${holderName}
+ constructor. These will have template substitution
+ performed on them so you can use things like ${val}.
+ This is a single string, not a list of strings.
+
+ ${declName} must be in scope before the code from 'template' is entered.
+
+ If holderType is not None then ${holderName} must be in scope before
+ the code from 'template' is entered.
+ """
+ assert isinstance(template, str)
+ assert declType is None or isinstance(declType, CGThing)
+ assert holderType is None or isinstance(holderType, CGThing)
+ self.template = template
+ self.declType = declType
+ self.holderType = holderType
+ self.dealWithOptional = dealWithOptional
+ self.declArgs = declArgs
+ self.holderArgs = holderArgs
+
+
+def getHandleDefault(defaultValue):
+ tag = defaultValue.type.tag()
+ if tag in numericSuffixes:
+ # Some numeric literals require a suffix to compile without warnings
+ return numericValue(tag, defaultValue.value)
+ assert tag == IDLType.Tags.bool
+ return toStringBool(defaultValue.value)
+
+
+def handleDefaultStringValue(defaultValue, method):
+ """
+ Returns a string which ends up calling 'method' with a (char_t*, length)
+ pair that sets this string default value. This string is suitable for
+ passing as the second argument of handleDefault; in particular it does not
+ end with a ';'
+ """
+ assert defaultValue.type.isDOMString() or defaultValue.type.isByteString()
+ return ("static const %(char_t)s data[] = { %(data)s };\n"
+ "%(method)s(data, ArrayLength(data) - 1)") % {
+ 'char_t': "char" if defaultValue.type.isByteString() else "char16_t",
+ 'method': method,
+ 'data': ", ".join(["'" + char + "'" for char in
+ defaultValue.value] + ["0"])
+ }
+
+
+# If this function is modified, modify CGNativeMember.getArg and
+# CGNativeMember.getRetvalInfo accordingly. The latter cares about the decltype
+# and holdertype we end up using, because it needs to be able to return the code
+# that will convert those to the actual return value of the callback function.
+def getJSToNativeConversionInfo(type, descriptorProvider, failureCode=None,
+ isDefinitelyObject=False,
+ isMember=False,
+ isOptional=False,
+ invalidEnumValueFatal=True,
+ defaultValue=None,
+ treatNullAs="Default",
+ isEnforceRange=False,
+ isClamp=False,
+ isNullOrUndefined=False,
+ exceptionCode=None,
+ lenientFloatCode=None,
+ allowTreatNonCallableAsNull=False,
+ isCallbackReturnValue=False,
+ sourceDescription="value",
+ nestingLevel=""):
+ """
+ Get a template for converting a JS value to a native object based on the
+ given type and descriptor. If failureCode is given, then we're actually
+ testing whether we can convert the argument to the desired type. That
+ means that failures to convert due to the JS value being the wrong type of
+ value need to use failureCode instead of throwing exceptions. Failures to
+ convert that are due to JS exceptions (from toString or valueOf methods) or
+ out of memory conditions need to throw exceptions no matter what
+ failureCode is. However what actually happens when throwing an exception
+ can be controlled by exceptionCode. The only requirement on that is that
+ exceptionCode must end up doing a return, and every return from this
+ function must happen via exceptionCode if exceptionCode is not None.
+
+ If isDefinitelyObject is True, that means we know the value
+ isObject() and we have no need to recheck that.
+
+ if isMember is not False, we're being converted from a property of some JS
+ object, not from an actual method argument, so we can't rely on our jsval
+ being rooted or outliving us in any way. Callers can pass "Dictionary",
+ "Variadic", "Sequence", or "OwningUnion" to indicate that the conversion is
+ for something that is a dictionary member, a variadic argument, a sequence,
+ or an owning union respectively.
+
+ If isOptional is true, then we are doing conversion of an optional
+ argument with no default value.
+
+ invalidEnumValueFatal controls whether an invalid enum value conversion
+ attempt will throw (if true) or simply return without doing anything (if
+ false).
+
+ If defaultValue is not None, it's the IDL default value for this conversion
+
+ If isEnforceRange is true, we're converting an integer and throwing if the
+ value is out of range.
+
+ If isClamp is true, we're converting an integer and clamping if the
+ value is out of range.
+
+ If lenientFloatCode is not None, it should be used in cases when
+ we're a non-finite float that's not unrestricted.
+
+ If allowTreatNonCallableAsNull is true, then [TreatNonCallableAsNull] and
+ [TreatNonObjectAsNull] extended attributes on nullable callback functions
+ will be honored.
+
+ If isCallbackReturnValue is "JSImpl" or "Callback", then the declType may be
+ adjusted to make it easier to return from a callback. Since that type is
+ never directly observable by any consumers of the callback code, this is OK.
+ Furthermore, if isCallbackReturnValue is "JSImpl", that affects the behavior
+ of the FailureFatalCastableObjectUnwrapper conversion; this is used for
+ implementing auto-wrapping of JS-implemented return values from a
+ JS-implemented interface.
+
+ sourceDescription is a description of what this JS value represents, to be
+ used in error reporting. Callers should assume that it might get placed in
+ the middle of a sentence. If it ends up at the beginning of a sentence, its
+ first character will be automatically uppercased.
+
+ The return value from this function is a JSToNativeConversionInfo.
+ """
+ # If we have a defaultValue then we're not actually optional for
+ # purposes of what we need to be declared as.
+ assert defaultValue is None or not isOptional
+
+ # Also, we should not have a defaultValue if we know we're an object
+ assert not isDefinitelyObject or defaultValue is None
+
+ # And we can't both be an object and be null or undefined
+ assert not isDefinitelyObject or not isNullOrUndefined
+
+ # If exceptionCode is not set, we'll just rethrow the exception we got.
+ # Note that we can't just set failureCode to exceptionCode, because setting
+ # failureCode will prevent pending exceptions from being set in cases when
+ # they really should be!
+ if exceptionCode is None:
+ exceptionCode = "return false;\n"
+
+ # Unfortunately, .capitalize() on a string will lowercase things inside the
+ # string, which we do not want.
+ def firstCap(string):
+ return string[0].upper() + string[1:]
+
+ # Helper functions for dealing with failures due to the JS value being the
+ # wrong type of value
+ def onFailureNotAnObject(failureCode):
+ return CGGeneric(
+ failureCode or
+ ('ThrowErrorMessage(cx, MSG_NOT_OBJECT, "%s");\n'
+ '%s' % (firstCap(sourceDescription), exceptionCode)))
+
+ def onFailureBadType(failureCode, typeName):
+ return CGGeneric(
+ failureCode or
+ ('ThrowErrorMessage(cx, MSG_DOES_NOT_IMPLEMENT_INTERFACE, "%s", "%s");\n'
+ '%s' % (firstCap(sourceDescription), typeName, exceptionCode)))
+
+ def onFailureNotCallable(failureCode):
+ return CGGeneric(
+ failureCode or
+ ('ThrowErrorMessage(cx, MSG_NOT_CALLABLE, "%s");\n'
+ '%s' % (firstCap(sourceDescription), exceptionCode)))
+
+ # A helper function for handling default values. Takes a template
+ # body and the C++ code to set the default value and wraps the
+ # given template body in handling for the default value.
+ def handleDefault(template, setDefault):
+ if defaultValue is None:
+ return template
+ return (
+ "if (${haveValue}) {\n" +
+ indent(template) +
+ "} else {\n" +
+ indent(setDefault) +
+ "}\n")
+
+ # A helper function for wrapping up the template body for
+ # possibly-nullable objecty stuff
+ def wrapObjectTemplate(templateBody, type, codeToSetNull, failureCode=None):
+ if isNullOrUndefined and type.nullable():
+ # Just ignore templateBody and set ourselves to null.
+ # Note that we don't have to worry about default values
+ # here either, since we already examined this value.
+ return codeToSetNull
+
+ if not isDefinitelyObject:
+ # Handle the non-object cases by wrapping up the whole
+ # thing in an if cascade.
+ if type.nullable():
+ elifLine = "} else if (${val}.isNullOrUndefined()) {\n"
+ elifBody = codeToSetNull
+ else:
+ elifLine = ""
+ elifBody = ""
+
+ # Note that $${val} below expands to ${val}. This string is
+ # used as a template later, and val will be filled in then.
+ templateBody = fill(
+ """
+ if ($${val}.isObject()) {
+ $*{templateBody}
+ $*{elifLine}
+ $*{elifBody}
+ } else {
+ $*{failureBody}
+ }
+ """,
+ templateBody=templateBody,
+ elifLine=elifLine,
+ elifBody=elifBody,
+ failureBody=onFailureNotAnObject(failureCode).define())
+
+ if isinstance(defaultValue, IDLNullValue):
+ assert type.nullable() # Parser should enforce this
+ templateBody = handleDefault(templateBody, codeToSetNull)
+ elif isinstance(defaultValue, IDLEmptySequenceValue):
+ # Our caller will handle it
+ pass
+ else:
+ assert defaultValue is None
+
+ return templateBody
+
+ # A helper function for converting things that look like a JSObject*.
+ def handleJSObjectType(type, isMember, failureCode, exceptionCode, sourceDescription):
+ if not isMember:
+ if isOptional:
+ # We have a specialization of Optional that will use a
+ # Rooted for the storage here.
+ declType = CGGeneric("JS::Handle<JSObject*>")
+ else:
+ declType = CGGeneric("JS::Rooted<JSObject*>")
+ declArgs = "cx"
+ else:
+ assert (isMember in
+ ("Sequence", "Variadic", "Dictionary", "OwningUnion", "MozMap"))
+ # We'll get traced by the sequence or dictionary or union tracer
+ declType = CGGeneric("JSObject*")
+ declArgs = None
+ templateBody = "${declName} = &${val}.toObject();\n"
+
+ # For JS-implemented APIs, we refuse to allow passing objects that the
+ # API consumer does not subsume. The extra parens around
+ # ($${passedToJSImpl}) suppress unreachable code warnings when
+ # $${passedToJSImpl} is the literal `false`.
+ if not isinstance(descriptorProvider, Descriptor) or descriptorProvider.interface.isJSImplemented():
+ templateBody = fill(
+ """
+ if (($${passedToJSImpl}) && !CallerSubsumes($${val})) {
+ ThrowErrorMessage(cx, MSG_PERMISSION_DENIED_TO_PASS_ARG, "${sourceDescription}");
+ $*{exceptionCode}
+ }
+ """,
+ sourceDescription=sourceDescription,
+ exceptionCode=exceptionCode) + templateBody
+
+ setToNullCode = "${declName} = nullptr;\n"
+ template = wrapObjectTemplate(templateBody, type, setToNullCode,
+ failureCode)
+ return JSToNativeConversionInfo(template, declType=declType,
+ dealWithOptional=isOptional,
+ declArgs=declArgs)
+
+ def incrementNestingLevel():
+ if nestingLevel is "":
+ return 1
+ return nestingLevel + 1
+
+ assert not (isEnforceRange and isClamp) # These are mutually exclusive
+
+ if type.isSequence():
+ assert not isEnforceRange and not isClamp
+
+ if failureCode is None:
+ notSequence = ('ThrowErrorMessage(cx, MSG_NOT_SEQUENCE, "%s");\n'
+ "%s" % (firstCap(sourceDescription), exceptionCode))
+ else:
+ notSequence = failureCode
+
+ nullable = type.nullable()
+ # Be very careful not to change "type": we need it later
+ if nullable:
+ elementType = type.inner.inner
+ else:
+ elementType = type.inner
+
+ # We want to use auto arrays if we can, but we have to be careful with
+ # reallocation behavior for arrays. In particular, if we use auto
+ # arrays for sequences and have a sequence of elements which are
+ # themselves sequences or have sequences as members, we have a problem.
+ # In that case, resizing the outermost AutoTArray to the right size
+ # will memmove its elements, but AutoTArrays are not memmovable and
+ # hence will end up with pointers to bogus memory, which is bad. To
+ # deal with this, we typically map WebIDL sequences to our Sequence
+ # type, which is in fact memmovable. The one exception is when we're
+ # passing in a sequence directly as an argument without any sort of
+ # optional or nullable complexity going on. In that situation, we can
+ # use an AutoSequence instead. We have to keep using Sequence in the
+ # nullable and optional cases because we don't want to leak the
+ # AutoSequence type to consumers, which would be unavoidable with
+ # Nullable<AutoSequence> or Optional<AutoSequence>.
+ if isMember or isOptional or nullable or isCallbackReturnValue:
+ sequenceClass = "Sequence"
+ else:
+ sequenceClass = "binding_detail::AutoSequence"
+
+ # XXXbz we can't include the index in the sourceDescription, because
+ # we don't really have a way to pass one in dynamically at runtime...
+ elementInfo = getJSToNativeConversionInfo(
+ elementType, descriptorProvider, isMember="Sequence",
+ exceptionCode=exceptionCode, lenientFloatCode=lenientFloatCode,
+ isCallbackReturnValue=isCallbackReturnValue,
+ sourceDescription="element of %s" % sourceDescription,
+ nestingLevel=incrementNestingLevel())
+ if elementInfo.dealWithOptional:
+ raise TypeError("Shouldn't have optional things in sequences")
+ if elementInfo.holderType is not None:
+ raise TypeError("Shouldn't need holders for sequences")
+
+ typeName = CGTemplatedType(sequenceClass, elementInfo.declType)
+ sequenceType = typeName.define()
+ if nullable:
+ typeName = CGTemplatedType("Nullable", typeName)
+ arrayRef = "${declName}.SetValue()"
+ else:
+ arrayRef = "${declName}"
+
+ elementConversion = string.Template(elementInfo.template).substitute({
+ "val": "temp" + str(nestingLevel),
+ "maybeMutableVal": "&temp" + str(nestingLevel),
+ "declName": "slot" + str(nestingLevel),
+ # We only need holderName here to handle isExternal()
+ # interfaces, which use an internal holder for the
+ # conversion even when forceOwningType ends up true.
+ "holderName": "tempHolder" + str(nestingLevel),
+ "passedToJSImpl": "${passedToJSImpl}"
+ })
+
+ # NOTE: Keep this in sync with variadic conversions as needed
+ templateBody = fill(
+ """
+ JS::ForOfIterator iter${nestingLevel}(cx);
+ if (!iter${nestingLevel}.init($${val}, JS::ForOfIterator::AllowNonIterable)) {
+ $*{exceptionCode}
+ }
+ if (!iter${nestingLevel}.valueIsIterable()) {
+ $*{notSequence}
+ }
+ ${sequenceType} &arr${nestingLevel} = ${arrayRef};
+ JS::Rooted<JS::Value> temp${nestingLevel}(cx);
+ while (true) {
+ bool done${nestingLevel};
+ if (!iter${nestingLevel}.next(&temp${nestingLevel}, &done${nestingLevel})) {
+ $*{exceptionCode}
+ }
+ if (done${nestingLevel}) {
+ break;
+ }
+ ${elementType}* slotPtr${nestingLevel} = arr${nestingLevel}.AppendElement(mozilla::fallible);
+ if (!slotPtr${nestingLevel}) {
+ JS_ReportOutOfMemory(cx);
+ $*{exceptionCode}
+ }
+ ${elementType}& slot${nestingLevel} = *slotPtr${nestingLevel};
+ $*{elementConversion}
+ }
+ """,
+ exceptionCode=exceptionCode,
+ notSequence=notSequence,
+ sequenceType=sequenceType,
+ arrayRef=arrayRef,
+ elementType=elementInfo.declType.define(),
+ elementConversion=elementConversion,
+ nestingLevel=str(nestingLevel))
+
+ templateBody = wrapObjectTemplate(templateBody, type,
+ "${declName}.SetNull();\n", notSequence)
+ if isinstance(defaultValue, IDLEmptySequenceValue):
+ if type.nullable():
+ codeToSetEmpty = "${declName}.SetValue();\n"
+ else:
+ codeToSetEmpty = "/* Array is already empty; nothing to do */\n"
+ templateBody = handleDefault(templateBody, codeToSetEmpty)
+
+ # Sequence arguments that might contain traceable things need
+ # to get traced
+ if not isMember and typeNeedsRooting(elementType):
+ holderType = CGTemplatedType("SequenceRooter", elementInfo.declType)
+ # If our sequence is nullable, this will set the Nullable to be
+ # not-null, but that's ok because we make an explicit SetNull() call
+ # on it as needed if our JS value is actually null.
+ holderArgs = "cx, &%s" % arrayRef
+ else:
+ holderType = None
+ holderArgs = None
+
+ return JSToNativeConversionInfo(templateBody, declType=typeName,
+ holderType=holderType,
+ dealWithOptional=isOptional,
+ holderArgs=holderArgs)
+
+ if type.isMozMap():
+ assert not isEnforceRange and not isClamp
+ if failureCode is None:
+ notMozMap = ('ThrowErrorMessage(cx, MSG_NOT_OBJECT, "%s");\n'
+ "%s" % (firstCap(sourceDescription), exceptionCode))
+ else:
+ notMozMap = failureCode
+
+ nullable = type.nullable()
+ # Be very careful not to change "type": we need it later
+ if nullable:
+ valueType = type.inner.inner
+ else:
+ valueType = type.inner
+
+ valueInfo = getJSToNativeConversionInfo(
+ valueType, descriptorProvider, isMember="MozMap",
+ exceptionCode=exceptionCode, lenientFloatCode=lenientFloatCode,
+ isCallbackReturnValue=isCallbackReturnValue,
+ sourceDescription="value in %s" % sourceDescription,
+ nestingLevel=incrementNestingLevel())
+ if valueInfo.dealWithOptional:
+ raise TypeError("Shouldn't have optional things in MozMap")
+ if valueInfo.holderType is not None:
+ raise TypeError("Shouldn't need holders for MozMap")
+
+ typeName = CGTemplatedType("MozMap", valueInfo.declType)
+ mozMapType = typeName.define()
+ if nullable:
+ typeName = CGTemplatedType("Nullable", typeName)
+ mozMapRef = "${declName}.SetValue()"
+ else:
+ mozMapRef = "${declName}"
+
+ valueConversion = string.Template(valueInfo.template).substitute({
+ "val": "temp",
+ "maybeMutableVal": "&temp",
+ "declName": "slot",
+ # We only need holderName here to handle isExternal()
+ # interfaces, which use an internal holder for the
+ # conversion even when forceOwningType ends up true.
+ "holderName": "tempHolder",
+ "passedToJSImpl": "${passedToJSImpl}"
+ })
+
+ templateBody = fill(
+ """
+ ${mozMapType} &mozMap = ${mozMapRef};
+
+ JS::Rooted<JSObject*> mozMapObj(cx, &$${val}.toObject());
+ JS::Rooted<JS::IdVector> ids(cx, JS::IdVector(cx));
+ if (!JS_Enumerate(cx, mozMapObj, &ids)) {
+ $*{exceptionCode}
+ }
+ JS::Rooted<JS::Value> propNameValue(cx);
+ JS::Rooted<JS::Value> temp(cx);
+ JS::Rooted<jsid> curId(cx);
+ for (size_t i = 0; i < ids.length(); ++i) {
+ // Make sure we get the value before converting the name, since
+ // getting the value can trigger GC but our name is a dependent
+ // string.
+ curId = ids[i];
+ binding_detail::FakeString propName;
+ bool isSymbol;
+ if (!ConvertIdToString(cx, curId, propName, isSymbol) ||
+ (!isSymbol && !JS_GetPropertyById(cx, mozMapObj, curId, &temp))) {
+ $*{exceptionCode}
+ }
+ if (isSymbol) {
+ continue;
+ }
+
+ ${valueType}* slotPtr = mozMap.AddEntry(propName);
+ if (!slotPtr) {
+ JS_ReportOutOfMemory(cx);
+ $*{exceptionCode}
+ }
+ ${valueType}& slot = *slotPtr;
+ $*{valueConversion}
+ }
+ """,
+ exceptionCode=exceptionCode,
+ mozMapType=mozMapType,
+ mozMapRef=mozMapRef,
+ valueType=valueInfo.declType.define(),
+ valueConversion=valueConversion)
+
+ templateBody = wrapObjectTemplate(templateBody, type,
+ "${declName}.SetNull();\n",
+ notMozMap)
+
+ declType = typeName
+ declArgs = None
+ holderType = None
+ holderArgs = None
+ # MozMap arguments that might contain traceable things need
+ # to get traced
+ if not isMember and isCallbackReturnValue:
+ # Go ahead and just convert directly into our actual return value
+ declType = CGWrapper(declType, post="&")
+ declArgs = "aRetVal"
+ elif not isMember and typeNeedsRooting(valueType):
+ holderType = CGTemplatedType("MozMapRooter", valueInfo.declType)
+ # If our MozMap is nullable, this will set the Nullable to be
+ # not-null, but that's ok because we make an explicit SetNull() call
+ # on it as needed if our JS value is actually null.
+ holderArgs = "cx, &%s" % mozMapRef
+
+ return JSToNativeConversionInfo(templateBody, declType=declType,
+ declArgs=declArgs,
+ holderType=holderType,
+ dealWithOptional=isOptional,
+ holderArgs=holderArgs)
+
+ if type.isUnion():
+ nullable = type.nullable()
+ if nullable:
+ type = type.inner
+
+ isOwningUnion = isMember or isCallbackReturnValue
+ unionArgumentObj = "${declName}" if isOwningUnion else "${holderName}"
+ if nullable:
+ # If we're owning, we're a Nullable, which hasn't been told it has
+ # a value. Otherwise we're an already-constructed Maybe.
+ unionArgumentObj += ".SetValue()" if isOwningUnion else ".ref()"
+
+ memberTypes = type.flatMemberTypes
+ names = []
+
+ interfaceMemberTypes = filter(lambda t: t.isNonCallbackInterface(), memberTypes)
+ if len(interfaceMemberTypes) > 0:
+ interfaceObject = []
+ for memberType in interfaceMemberTypes:
+ name = getUnionMemberName(memberType)
+ interfaceObject.append(
+ CGGeneric("(failed = !%s.TrySetTo%s(cx, ${val}, tryNext, ${passedToJSImpl})) || !tryNext" %
+ (unionArgumentObj, name)))
+ names.append(name)
+ interfaceObject = CGWrapper(CGList(interfaceObject, " ||\n"),
+ pre="done = ", post=";\n\n", reindent=True)
+ else:
+ interfaceObject = None
+
+ sequenceObjectMemberTypes = filter(lambda t: t.isSequence(), memberTypes)
+ if len(sequenceObjectMemberTypes) > 0:
+ assert len(sequenceObjectMemberTypes) == 1
+ name = getUnionMemberName(sequenceObjectMemberTypes[0])
+ sequenceObject = CGGeneric(
+ "done = (failed = !%s.TrySetTo%s(cx, ${val}, tryNext, ${passedToJSImpl})) || !tryNext;\n" %
+ (unionArgumentObj, name))
+ names.append(name)
+ else:
+ sequenceObject = None
+
+ dateObjectMemberTypes = filter(lambda t: t.isDate(), memberTypes)
+ if len(dateObjectMemberTypes) > 0:
+ assert len(dateObjectMemberTypes) == 1
+ memberType = dateObjectMemberTypes[0]
+ name = getUnionMemberName(memberType)
+ dateObject = CGGeneric("%s.SetTo%s(cx, ${val});\n"
+ "done = true;\n" % (unionArgumentObj, name))
+ dateObject = CGIfWrapper(dateObject, "JS_ObjectIsDate(cx, argObj)")
+ names.append(name)
+ else:
+ dateObject = None
+
+ callbackMemberTypes = filter(lambda t: t.isCallback() or t.isCallbackInterface(), memberTypes)
+ if len(callbackMemberTypes) > 0:
+ assert len(callbackMemberTypes) == 1
+ memberType = callbackMemberTypes[0]
+ name = getUnionMemberName(memberType)
+ callbackObject = CGGeneric(
+ "done = (failed = !%s.TrySetTo%s(cx, ${val}, tryNext, ${passedToJSImpl})) || !tryNext;\n" %
+ (unionArgumentObj, name))
+ names.append(name)
+ else:
+ callbackObject = None
+
+ dictionaryMemberTypes = filter(lambda t: t.isDictionary(), memberTypes)
+ if len(dictionaryMemberTypes) > 0:
+ assert len(dictionaryMemberTypes) == 1
+ name = getUnionMemberName(dictionaryMemberTypes[0])
+ setDictionary = CGGeneric(
+ "done = (failed = !%s.TrySetTo%s(cx, ${val}, tryNext, ${passedToJSImpl})) || !tryNext;\n" %
+ (unionArgumentObj, name))
+ names.append(name)
+ else:
+ setDictionary = None
+
+ mozMapMemberTypes = filter(lambda t: t.isMozMap(), memberTypes)
+ if len(mozMapMemberTypes) > 0:
+ assert len(mozMapMemberTypes) == 1
+ name = getUnionMemberName(mozMapMemberTypes[0])
+ mozMapObject = CGGeneric(
+ "done = (failed = !%s.TrySetTo%s(cx, ${val}, tryNext, ${passedToJSImpl})) || !tryNext;\n" %
+ (unionArgumentObj, name))
+ names.append(name)
+ else:
+ mozMapObject = None
+
+ objectMemberTypes = filter(lambda t: t.isObject(), memberTypes)
+ if len(objectMemberTypes) > 0:
+ assert len(objectMemberTypes) == 1
+ # Very important to NOT construct a temporary Rooted here, since the
+ # SetToObject call can call a Rooted constructor and we need to keep
+ # stack discipline for Rooted.
+ object = CGGeneric("if (!%s.SetToObject(cx, &${val}.toObject(), ${passedToJSImpl})) {\n"
+ "%s"
+ "}\n"
+ "done = true;\n" % (unionArgumentObj, indent(exceptionCode)))
+ names.append(objectMemberTypes[0].name)
+ else:
+ object = None
+
+ hasObjectTypes = interfaceObject or sequenceObject or dateObject or callbackObject or object or mozMapObject
+ if hasObjectTypes:
+ # "object" is not distinguishable from other types
+ assert not object or not (interfaceObject or sequenceObject or dateObject or callbackObject or mozMapObject)
+ if sequenceObject or dateObject or callbackObject:
+ # An object can be both an sequence object and a callback or
+ # dictionary, but we shouldn't have both in the union's members
+ # because they are not distinguishable.
+ assert not (sequenceObject and callbackObject)
+ templateBody = CGElseChain([sequenceObject, dateObject, callbackObject])
+ else:
+ templateBody = None
+ if interfaceObject:
+ assert not object
+ if templateBody:
+ templateBody = CGIfWrapper(templateBody, "!done")
+ templateBody = CGList([interfaceObject, templateBody])
+ else:
+ templateBody = CGList([templateBody, object])
+
+ if dateObject:
+ templateBody.prepend(CGGeneric("JS::Rooted<JSObject*> argObj(cx, &${val}.toObject());\n"))
+
+ if mozMapObject:
+ templateBody = CGList([templateBody,
+ CGIfWrapper(mozMapObject, "!done")])
+
+ templateBody = CGIfWrapper(templateBody, "${val}.isObject()")
+ else:
+ templateBody = CGGeneric()
+
+ if setDictionary:
+ assert not object
+ templateBody = CGList([templateBody,
+ CGIfWrapper(setDictionary, "!done")])
+
+ stringTypes = [t for t in memberTypes if t.isString() or t.isEnum()]
+ numericTypes = [t for t in memberTypes if t.isNumeric()]
+ booleanTypes = [t for t in memberTypes if t.isBoolean()]
+ if stringTypes or numericTypes or booleanTypes:
+ assert len(stringTypes) <= 1
+ assert len(numericTypes) <= 1
+ assert len(booleanTypes) <= 1
+
+ # We will wrap all this stuff in a do { } while (0); so we
+ # can use "break" for flow control.
+ def getStringOrPrimitiveConversion(memberType):
+ name = getUnionMemberName(memberType)
+ return CGGeneric("done = (failed = !%s.TrySetTo%s(cx, ${val}, tryNext)) || !tryNext;\n"
+ "break;\n" % (unionArgumentObj, name))
+ other = CGList([])
+ stringConversion = map(getStringOrPrimitiveConversion, stringTypes)
+ numericConversion = map(getStringOrPrimitiveConversion, numericTypes)
+ booleanConversion = map(getStringOrPrimitiveConversion, booleanTypes)
+ if stringConversion:
+ if booleanConversion:
+ other.append(CGIfWrapper(booleanConversion[0],
+ "${val}.isBoolean()"))
+ if numericConversion:
+ other.append(CGIfWrapper(numericConversion[0],
+ "${val}.isNumber()"))
+ other.append(stringConversion[0])
+ elif numericConversion:
+ if booleanConversion:
+ other.append(CGIfWrapper(booleanConversion[0],
+ "${val}.isBoolean()"))
+ other.append(numericConversion[0])
+ else:
+ assert booleanConversion
+ other.append(booleanConversion[0])
+
+ other = CGWrapper(CGIndenter(other), pre="do {\n", post="} while (0);\n")
+ if hasObjectTypes or setDictionary:
+ other = CGWrapper(CGIndenter(other), "{\n", post="}\n")
+ if object:
+ templateBody = CGElseChain([templateBody, other])
+ else:
+ other = CGWrapper(other, pre="if (!done) ")
+ templateBody = CGList([templateBody, other])
+ else:
+ assert templateBody.define() == ""
+ templateBody = other
+ else:
+ other = None
+
+ templateBody = CGWrapper(templateBody, pre="bool done = false, failed = false, tryNext;\n")
+ throw = CGGeneric(fill(
+ """
+ if (failed) {
+ $*{exceptionCode}
+ }
+ if (!done) {
+ ThrowErrorMessage(cx, MSG_NOT_IN_UNION, "${desc}", "${names}");
+ $*{exceptionCode}
+ }
+ """,
+ exceptionCode=exceptionCode,
+ desc=firstCap(sourceDescription),
+ names=", ".join(names)))
+
+ templateBody = CGWrapper(CGIndenter(CGList([templateBody, throw])), pre="{\n", post="}\n")
+
+ typeName = CGUnionStruct.unionTypeDecl(type, isOwningUnion)
+ argumentTypeName = typeName + "Argument"
+ if nullable:
+ typeName = "Nullable<" + typeName + " >"
+
+ def handleNull(templateBody, setToNullVar, extraConditionForNull=""):
+ nullTest = "%s${val}.isNullOrUndefined()" % extraConditionForNull
+ return CGIfElseWrapper(nullTest,
+ CGGeneric("%s.SetNull();\n" % setToNullVar),
+ templateBody)
+
+ if type.hasNullableType:
+ assert not nullable
+ # Make sure to handle a null default value here
+ if defaultValue and isinstance(defaultValue, IDLNullValue):
+ assert defaultValue.type == type
+ extraConditionForNull = "!(${haveValue}) || "
+ else:
+ extraConditionForNull = ""
+ templateBody = handleNull(templateBody, unionArgumentObj,
+ extraConditionForNull=extraConditionForNull)
+
+ declType = CGGeneric(typeName)
+ if isOwningUnion:
+ holderType = None
+ else:
+ holderType = CGGeneric(argumentTypeName)
+ if nullable:
+ holderType = CGTemplatedType("Maybe", holderType)
+
+ # If we're isOptional and not nullable the normal optional handling will
+ # handle lazy construction of our holder. If we're nullable and not
+ # owning we do it all by hand because we do not want our holder
+ # constructed if we're null. But if we're owning we don't have a
+ # holder anyway, so we can do the normal Optional codepath.
+ declLoc = "${declName}"
+ constructDecl = None
+ if nullable:
+ if isOptional and not isOwningUnion:
+ holderArgs = "${declName}.Value().SetValue()"
+ declType = CGTemplatedType("Optional", declType)
+ constructDecl = CGGeneric("${declName}.Construct();\n")
+ declLoc = "${declName}.Value()"
+ else:
+ holderArgs = "${declName}.SetValue()"
+ if holderType is not None:
+ constructHolder = CGGeneric("${holderName}.emplace(%s);\n" % holderArgs)
+ else:
+ constructHolder = None
+ # Don't need to pass those args when the holder is being constructed
+ holderArgs = None
+ else:
+ holderArgs = "${declName}"
+ constructHolder = None
+
+ if not isMember and isCallbackReturnValue:
+ declType = CGWrapper(declType, post="&")
+ declArgs = "aRetVal"
+ else:
+ declArgs = None
+
+ if defaultValue and not isinstance(defaultValue, IDLNullValue):
+ tag = defaultValue.type.tag()
+
+ if tag in numericSuffixes or tag is IDLType.Tags.bool:
+ defaultStr = getHandleDefault(defaultValue)
+ # Make sure we actually construct the thing inside the nullable.
+ value = declLoc + (".SetValue()" if nullable else "")
+ name = getUnionMemberName(defaultValue.type)
+ default = CGGeneric("%s.RawSetAs%s() = %s;\n" %
+ (value, name, defaultStr))
+ elif isinstance(defaultValue, IDLEmptySequenceValue):
+ name = getUnionMemberName(defaultValue.type)
+ # Make sure we actually construct the thing inside the nullable.
+ value = declLoc + (".SetValue()" if nullable else "")
+ # It's enough to set us to the right type; that will
+ # create an empty array, which is all we need here.
+ default = CGGeneric("%s.RawSetAs%s();\n" %
+ (value, name))
+ elif defaultValue.type.isEnum():
+ name = getUnionMemberName(defaultValue.type)
+ # Make sure we actually construct the thing inside the nullable.
+ value = declLoc + (".SetValue()" if nullable else "")
+ default = CGGeneric(
+ "%s.RawSetAs%s() = %s::%s;\n" %
+ (value, name,
+ defaultValue.type.inner.identifier.name,
+ getEnumValueName(defaultValue.value)))
+ else:
+ default = CGGeneric(
+ handleDefaultStringValue(
+ defaultValue, "%s.SetStringData" % unionArgumentObj) +
+ ";\n")
+
+ templateBody = CGIfElseWrapper("!(${haveValue})", default, templateBody)
+
+ templateBody = CGList([constructHolder, templateBody])
+
+ if nullable:
+ if defaultValue:
+ if isinstance(defaultValue, IDLNullValue):
+ extraConditionForNull = "!(${haveValue}) || "
+ else:
+ extraConditionForNull = "${haveValue} && "
+ else:
+ extraConditionForNull = ""
+ templateBody = handleNull(templateBody, declLoc,
+ extraConditionForNull=extraConditionForNull)
+ elif (not type.hasNullableType and defaultValue and
+ isinstance(defaultValue, IDLNullValue)):
+ assert type.hasDictionaryType()
+ assert defaultValue.type.isDictionary()
+ if not isOwningUnion and typeNeedsRooting(defaultValue.type):
+ ctorArgs = "cx"
+ else:
+ ctorArgs = ""
+ initDictionaryWithNull = CGIfWrapper(
+ CGGeneric("return false;\n"),
+ ('!%s.RawSetAs%s(%s).Init(cx, JS::NullHandleValue, "Member of %s")'
+ % (declLoc, getUnionMemberName(defaultValue.type),
+ ctorArgs, type)))
+ templateBody = CGIfElseWrapper("!(${haveValue})",
+ initDictionaryWithNull,
+ templateBody)
+
+ templateBody = CGList([constructDecl, templateBody])
+
+ return JSToNativeConversionInfo(templateBody.define(),
+ declType=declType,
+ declArgs=declArgs,
+ holderType=holderType,
+ holderArgs=holderArgs,
+ dealWithOptional=isOptional and (not nullable or isOwningUnion))
+
+ if type.isGeckoInterface():
+ assert not isEnforceRange and not isClamp
+
+ descriptor = descriptorProvider.getDescriptor(
+ type.unroll().inner.identifier.name)
+
+ assert descriptor.nativeType != 'JSObject'
+
+ if descriptor.interface.isCallback():
+ (declType, declArgs,
+ conversion) = getCallbackConversionInfo(type, descriptor.interface,
+ isMember,
+ isCallbackReturnValue,
+ isOptional)
+ template = wrapObjectTemplate(conversion, type,
+ "${declName} = nullptr;\n",
+ failureCode)
+ return JSToNativeConversionInfo(template, declType=declType,
+ declArgs=declArgs,
+ dealWithOptional=isOptional)
+
+ # This is an interface that we implement as a concrete class
+ # or an XPCOM interface.
+
+ # Allow null pointers for nullable types and old-binding classes, and
+ # use an RefPtr or raw pointer for callback return values to make
+ # them easier to return.
+ argIsPointer = (type.nullable() or type.unroll().inner.isExternal() or
+ isCallbackReturnValue)
+
+ # Sequence and dictionary members, as well as owning unions (which can
+ # appear here as return values in JS-implemented interfaces) have to
+ # hold a strong ref to the thing being passed down. Those all set
+ # isMember.
+ #
+ # Also, callback return values always end up addrefing anyway, so there
+ # is no point trying to avoid it here and it makes other things simpler
+ # since we can assume the return value is a strong ref.
+ #
+ # Finally, promises need to hold a strong ref because that's what
+ # Promise.resolve returns.
+ assert not descriptor.interface.isCallback()
+ isPromise = descriptor.interface.identifier.name == "Promise"
+ forceOwningType = isMember or isCallbackReturnValue or isPromise
+
+ typeName = descriptor.nativeType
+ typePtr = typeName + "*"
+
+ # Compute a few things:
+ # - declType is the type we want to return as the first element of our
+ # tuple.
+ # - holderType is the type we want to return as the third element
+ # of our tuple.
+
+ # Set up some sensible defaults for these things insofar as we can.
+ holderType = None
+ if argIsPointer:
+ if forceOwningType:
+ declType = "RefPtr<" + typeName + ">"
+ else:
+ declType = typePtr
+ else:
+ if forceOwningType:
+ declType = "OwningNonNull<" + typeName + ">"
+ else:
+ declType = "NonNull<" + typeName + ">"
+
+ templateBody = ""
+ if forceOwningType:
+ templateBody += 'static_assert(IsRefcounted<%s>::value, "We can only store refcounted classes.");' % typeName
+
+ if isPromise:
+ # Per spec, what we're supposed to do is take the original
+ # Promise.resolve and call it with the original Promise as this
+ # value to make a Promise out of whatever value we actually have
+ # here. The question is which global we should use. There are
+ # several cases to consider:
+ #
+ # 1) Normal call to API with a Promise argument. This is a case the
+ # spec covers, and we should be using the current Realm's
+ # Promise. That means the current compartment.
+ # 2) Call to API with a Promise argument over Xrays. In practice,
+ # this sort of thing seems to be used for giving an API
+ # implementation a way to wait for conclusion of an asyc
+ # operation, _not_ to expose the Promise to content code. So we
+ # probably want to allow callers to use such an API in a
+ # "natural" way, by passing chrome-side promises; indeed, that
+ # may be all that the caller has to represent their async
+ # operation. That means we really need to do the
+ # Promise.resolve() in the caller (chrome) compartment: if we do
+ # it in the content compartment, we will try to call .then() on
+ # the chrome promise while in the content compartment, which will
+ # throw and we'll just get a rejected Promise. Note that this is
+ # also the reason why a caller who has a chrome Promise
+ # representing an async operation can't itself convert it to a
+ # content-side Promise (at least not without some serious
+ # gyrations).
+ # 3) Promise return value from a callback or callback interface.
+ # This is in theory a case the spec covers but in practice it
+ # really doesn't define behavior here because it doesn't define
+ # what Realm we're in after the callback returns, which is when
+ # the argument conversion happens. We will use the current
+ # compartment, which is the compartment of the callable (which
+ # may itself be a cross-compartment wrapper itself), which makes
+ # as much sense as anything else. In practice, such an API would
+ # once again be providing a Promise to signal completion of an
+ # operation, which would then not be exposed to anyone other than
+ # our own implementation code.
+ # 4) Return value from a JS-implemented interface. In this case we
+ # have a problem. Our current compartment is the compartment of
+ # the JS implementation. But if the JS implementation returned
+ # a page-side Promise (which is a totally sane thing to do, and
+ # in fact the right thing to do given that this return value is
+ # going right to content script) then we don't want to
+ # Promise.resolve with our current compartment Promise, because
+ # that will wrap it up in a chrome-side Promise, which is
+ # decidedly _not_ what's desired here. So in that case we
+ # should really unwrap the return value and use the global of
+ # the result. CheckedUnwrap should be good enough for that; if
+ # it fails, then we're failing unwrap while in a
+ # system-privileged compartment, so presumably we have a dead
+ # object wrapper. Just error out. Do NOT fall back to using
+ # the current compartment instead: that will return a
+ # system-privileged rejected (because getting .then inside
+ # resolve() failed) Promise to the caller, which they won't be
+ # able to touch. That's not helpful. If we error out, on the
+ # other hand, they will get a content-side rejected promise.
+ # Same thing if the value returned is not even an object.
+ if isCallbackReturnValue == "JSImpl":
+ # Case 4 above. Note that globalObj defaults to the current
+ # compartment global. Note that we don't use $*{exceptionCode}
+ # here because that will try to aRv.Throw(NS_ERROR_UNEXPECTED)
+ # which we don't really want here.
+ assert exceptionCode == "aRv.Throw(NS_ERROR_UNEXPECTED);\nreturn nullptr;\n"
+ getPromiseGlobal = fill(
+ """
+ if (!$${val}.isObject()) {
+ aRv.ThrowTypeError<MSG_NOT_OBJECT>(NS_LITERAL_STRING("${sourceDescription}"));
+ return nullptr;
+ }
+ JSObject* unwrappedVal = js::CheckedUnwrap(&$${val}.toObject());
+ if (!unwrappedVal) {
+ // A slight lie, but not much of one, for a dead object wrapper.
+ aRv.ThrowTypeError<MSG_NOT_OBJECT>(NS_LITERAL_STRING("${sourceDescription}"));
+ return nullptr;
+ }
+ globalObj = js::GetGlobalForObjectCrossCompartment(unwrappedVal);
+ """,
+ sourceDescription=sourceDescription)
+ else:
+ getPromiseGlobal = ""
+
+ templateBody = fill(
+ """
+ { // Scope for our GlobalObject, FastErrorResult, JSAutoCompartment,
+ // etc.
+
+ JS::Rooted<JSObject*> globalObj(cx, JS::CurrentGlobalOrNull(cx));
+ $*{getPromiseGlobal}
+ JSAutoCompartment ac(cx, globalObj);
+ GlobalObject promiseGlobal(cx, globalObj);
+ if (promiseGlobal.Failed()) {
+ $*{exceptionCode}
+ }
+
+ JS::Rooted<JS::Value> valueToResolve(cx, $${val});
+ if (!JS_WrapValue(cx, &valueToResolve)) {
+ $*{exceptionCode}
+ }
+ binding_detail::FastErrorResult promiseRv;
+ #ifdef SPIDERMONKEY_PROMISE
+ nsCOMPtr<nsIGlobalObject> global =
+ do_QueryInterface(promiseGlobal.GetAsSupports());
+ if (!global) {
+ promiseRv.Throw(NS_ERROR_UNEXPECTED);
+ promiseRv.MaybeSetPendingException(cx);
+ $*{exceptionCode}
+ }
+ $${declName} = Promise::Resolve(global, cx, valueToResolve,
+ promiseRv);
+ if (promiseRv.MaybeSetPendingException(cx)) {
+ $*{exceptionCode}
+ }
+ #else
+ JS::Handle<JSObject*> promiseCtor =
+ PromiseBinding::GetConstructorObjectHandle(cx);
+ if (!promiseCtor) {
+ $*{exceptionCode}
+ }
+ JS::Rooted<JS::Value> resolveThisv(cx, JS::ObjectValue(*promiseCtor));
+ JS::Rooted<JS::Value> resolveResult(cx);
+ Promise::Resolve(promiseGlobal, resolveThisv, valueToResolve,
+ &resolveResult, promiseRv);
+ if (promiseRv.MaybeSetPendingException(cx)) {
+ $*{exceptionCode}
+ }
+ nsresult unwrapRv = UNWRAP_OBJECT(Promise, &resolveResult.toObject(), $${declName});
+ if (NS_FAILED(unwrapRv)) { // Quite odd
+ promiseRv.Throw(unwrapRv);
+ promiseRv.MaybeSetPendingException(cx);
+ $*{exceptionCode}
+ }
+ #endif // SPIDERMONKEY_PROMISE
+ }
+ """,
+ getPromiseGlobal=getPromiseGlobal,
+ exceptionCode=exceptionCode)
+ elif not descriptor.interface.isConsequential() and not descriptor.interface.isExternal():
+ if failureCode is not None:
+ templateBody += str(CastableObjectUnwrapper(
+ descriptor,
+ "${val}",
+ "${maybeMutableVal}",
+ "${declName}",
+ failureCode))
+ else:
+ templateBody += str(FailureFatalCastableObjectUnwrapper(
+ descriptor,
+ "${val}",
+ "${maybeMutableVal}",
+ "${declName}",
+ exceptionCode,
+ isCallbackReturnValue,
+ firstCap(sourceDescription)))
+ else:
+ # Either external, or new-binding non-castable. We always have a
+ # holder for these, because we don't actually know whether we have
+ # to addref when unwrapping or not. So we just pass an
+ # getter_AddRefs(RefPtr) to XPConnect and if we'll need a release
+ # it'll put a non-null pointer in there.
+ if forceOwningType:
+ # Don't return a holderType in this case; our declName
+ # will just own stuff.
+ templateBody += "RefPtr<" + typeName + "> ${holderName};\n"
+ else:
+ holderType = "RefPtr<" + typeName + ">"
+ templateBody += (
+ "JS::Rooted<JSObject*> source(cx, &${val}.toObject());\n" +
+ "if (NS_FAILED(UnwrapArg<" + typeName + ">(source, getter_AddRefs(${holderName})))) {\n")
+ templateBody += CGIndenter(onFailureBadType(failureCode,
+ descriptor.interface.identifier.name)).define()
+ templateBody += ("}\n"
+ "MOZ_ASSERT(${holderName});\n")
+
+ # And store our value in ${declName}
+ templateBody += "${declName} = ${holderName};\n"
+
+ if isPromise:
+ if type.nullable():
+ codeToSetNull = "${declName} = nullptr;\n"
+ templateBody = CGIfElseWrapper(
+ "${val}.isNullOrUndefined()",
+ CGGeneric(codeToSetNull),
+ CGGeneric(templateBody)).define()
+ if isinstance(defaultValue, IDLNullValue):
+ templateBody = handleDefault(templateBody, codeToSetNull)
+ else:
+ assert defaultValue is None
+ else:
+ # Just pass failureCode, not onFailureBadType, here, so we'll report
+ # the thing as not an object as opposed to not implementing whatever
+ # our interface is.
+ templateBody = wrapObjectTemplate(templateBody, type,
+ "${declName} = nullptr;\n",
+ failureCode)
+
+ declType = CGGeneric(declType)
+ if holderType is not None:
+ holderType = CGGeneric(holderType)
+ return JSToNativeConversionInfo(templateBody,
+ declType=declType,
+ holderType=holderType,
+ dealWithOptional=isOptional)
+
+ if type.isSpiderMonkeyInterface():
+ assert not isEnforceRange and not isClamp
+ name = type.unroll().name # unroll() because it may be nullable
+ arrayType = CGGeneric(name)
+ declType = arrayType
+ if type.nullable():
+ declType = CGTemplatedType("Nullable", declType)
+ objRef = "${declName}.SetValue()"
+ else:
+ objRef = "${declName}"
+
+ # Again, this is a bit strange since we are actually building a
+ # template string here. ${objRef} and $*{badType} below are filled in
+ # right now; $${val} expands to ${val}, to be filled in later.
+ template = fill(
+ """
+ if (!${objRef}.Init(&$${val}.toObject())) {
+ $*{badType}
+ }
+ """,
+ objRef=objRef,
+ badType=onFailureBadType(failureCode, type.name).define())
+ template = wrapObjectTemplate(template, type, "${declName}.SetNull();\n",
+ failureCode)
+ if not isMember:
+ # This is a bit annoying. In a union we don't want to have a
+ # holder, since unions don't support that. But if we're optional we
+ # want to have a holder, so that the callee doesn't see
+ # Optional<RootedTypedArray<ArrayType> >. So do a holder if we're
+ # optional and use a RootedTypedArray otherwise.
+ if isOptional:
+ holderType = CGTemplatedType("TypedArrayRooter", arrayType)
+ # If our typed array is nullable, this will set the Nullable to
+ # be not-null, but that's ok because we make an explicit
+ # SetNull() call on it as needed if our JS value is actually
+ # null. XXXbz Because "Maybe" takes const refs for constructor
+ # arguments, we can't pass a reference here; have to pass a
+ # pointer.
+ holderArgs = "cx, &%s" % objRef
+ declArgs = None
+ else:
+ holderType = None
+ holderArgs = None
+ declType = CGTemplatedType("RootedTypedArray", declType)
+ declArgs = "cx"
+ else:
+ holderType = None
+ holderArgs = None
+ declArgs = None
+ return JSToNativeConversionInfo(template,
+ declType=declType,
+ holderType=holderType,
+ dealWithOptional=isOptional,
+ declArgs=declArgs,
+ holderArgs=holderArgs)
+
+ if type.isDOMString() or type.isUSVString():
+ assert not isEnforceRange and not isClamp
+
+ treatAs = {
+ "Default": "eStringify",
+ "EmptyString": "eEmpty",
+ "Null": "eNull",
+ }
+ if type.nullable():
+ # For nullable strings null becomes a null string.
+ treatNullAs = "Null"
+ # For nullable strings undefined also becomes a null string.
+ undefinedBehavior = "eNull"
+ else:
+ undefinedBehavior = "eStringify"
+ nullBehavior = treatAs[treatNullAs]
+
+ def getConversionCode(varName):
+ normalizeCode = ""
+ if type.isUSVString():
+ normalizeCode = "NormalizeUSVString(cx, %s);\n" % varName
+
+ conversionCode = fill("""
+ if (!ConvertJSValueToString(cx, $${val}, ${nullBehavior}, ${undefinedBehavior}, ${varName})) {
+ $*{exceptionCode}
+ }
+ $*{normalizeCode}
+ """
+ ,
+ nullBehavior=nullBehavior,
+ undefinedBehavior=undefinedBehavior,
+ varName=varName,
+ exceptionCode=exceptionCode,
+ normalizeCode=normalizeCode)
+
+ if defaultValue is None:
+ return conversionCode
+
+ if isinstance(defaultValue, IDLNullValue):
+ assert(type.nullable())
+ defaultCode = "%s.SetIsVoid(true)" % varName
+ else:
+ defaultCode = handleDefaultStringValue(defaultValue,
+ "%s.Rebind" % varName)
+ return handleDefault(conversionCode, defaultCode + ";\n")
+
+ if isMember:
+ # Convert directly into the nsString member we have.
+ declType = CGGeneric("nsString")
+ return JSToNativeConversionInfo(
+ getConversionCode("${declName}"),
+ declType=declType,
+ dealWithOptional=isOptional)
+
+ if isOptional:
+ declType = "Optional<nsAString>"
+ holderType = CGGeneric("binding_detail::FakeString")
+ conversionCode = ("%s"
+ "${declName} = &${holderName};\n" %
+ getConversionCode("${holderName}"))
+ else:
+ declType = "binding_detail::FakeString"
+ holderType = None
+ conversionCode = getConversionCode("${declName}")
+
+ # No need to deal with optional here; we handled it already
+ return JSToNativeConversionInfo(
+ conversionCode,
+ declType=CGGeneric(declType),
+ holderType=holderType)
+
+ if type.isByteString():
+ assert not isEnforceRange and not isClamp
+
+ nullable = toStringBool(type.nullable())
+
+ conversionCode = fill("""
+ if (!ConvertJSValueToByteString(cx, $${val}, ${nullable}, $${declName})) {
+ $*{exceptionCode}
+ }
+ """,
+ nullable=nullable,
+ exceptionCode=exceptionCode)
+
+ if defaultValue is not None:
+ if isinstance(defaultValue, IDLNullValue):
+ assert(type.nullable())
+ defaultCode = "${declName}.SetIsVoid(true)"
+ else:
+ defaultCode = handleDefaultStringValue(defaultValue,
+ "${declName}.Rebind")
+ conversionCode = handleDefault(conversionCode, defaultCode + ";\n")
+
+ return JSToNativeConversionInfo(
+ conversionCode,
+ declType=CGGeneric("nsCString"),
+ dealWithOptional=isOptional)
+
+ if type.isEnum():
+ assert not isEnforceRange and not isClamp
+
+ enumName = type.unroll().inner.identifier.name
+ declType = CGGeneric(enumName)
+ if type.nullable():
+ declType = CGTemplatedType("Nullable", declType)
+ declType = declType.define()
+ enumLoc = "${declName}.SetValue()"
+ else:
+ enumLoc = "${declName}"
+ declType = declType.define()
+
+ if invalidEnumValueFatal:
+ handleInvalidEnumValueCode = "MOZ_ASSERT(index >= 0);\n"
+ else:
+ # invalidEnumValueFatal is false only for attributes. So we won't
+ # have a non-default exceptionCode here unless attribute "arg
+ # conversion" code starts passing in an exceptionCode. At which
+ # point we'll need to figure out what that even means.
+ assert exceptionCode == "return false;\n"
+ handleInvalidEnumValueCode = dedent("""
+ if (index < 0) {
+ return true;
+ }
+ """)
+
+ template = fill(
+ """
+ {
+ int index;
+ if (!FindEnumStringIndex<${invalidEnumValueFatal}>(cx, $${val}, ${values}, "${enumtype}", "${sourceDescription}", &index)) {
+ $*{exceptionCode}
+ }
+ $*{handleInvalidEnumValueCode}
+ ${enumLoc} = static_cast<${enumtype}>(index);
+ }
+ """,
+ enumtype=enumName,
+ values=enumName + "Values::" + ENUM_ENTRY_VARIABLE_NAME,
+ invalidEnumValueFatal=toStringBool(invalidEnumValueFatal),
+ handleInvalidEnumValueCode=handleInvalidEnumValueCode,
+ exceptionCode=exceptionCode,
+ enumLoc=enumLoc,
+ sourceDescription=firstCap(sourceDescription))
+
+ setNull = "${declName}.SetNull();\n"
+
+ if type.nullable():
+ template = CGIfElseWrapper("${val}.isNullOrUndefined()",
+ CGGeneric(setNull),
+ CGGeneric(template)).define()
+
+ if defaultValue is not None:
+ if isinstance(defaultValue, IDLNullValue):
+ assert type.nullable()
+ template = handleDefault(template, setNull)
+ else:
+ assert(defaultValue.type.tag() == IDLType.Tags.domstring)
+ template = handleDefault(template,
+ ("%s = %s::%s;\n" %
+ (enumLoc, enumName,
+ getEnumValueName(defaultValue.value))))
+ return JSToNativeConversionInfo(template, declType=CGGeneric(declType),
+ dealWithOptional=isOptional)
+
+ if type.isCallback():
+ assert not isEnforceRange and not isClamp
+ assert not type.treatNonCallableAsNull() or type.nullable()
+ assert not type.treatNonObjectAsNull() or type.nullable()
+ assert not type.treatNonObjectAsNull() or not type.treatNonCallableAsNull()
+
+ callback = type.unroll().callback
+ name = callback.identifier.name
+ (declType, declArgs,
+ conversion) = getCallbackConversionInfo(type, callback, isMember,
+ isCallbackReturnValue,
+ isOptional)
+
+ if allowTreatNonCallableAsNull and type.treatNonCallableAsNull():
+ haveCallable = "JS::IsCallable(&${val}.toObject())"
+ if not isDefinitelyObject:
+ haveCallable = "${val}.isObject() && " + haveCallable
+ if defaultValue is not None:
+ assert(isinstance(defaultValue, IDLNullValue))
+ haveCallable = "${haveValue} && " + haveCallable
+ template = (
+ ("if (%s) {\n" % haveCallable) +
+ conversion +
+ "} else {\n"
+ " ${declName} = nullptr;\n"
+ "}\n")
+ elif allowTreatNonCallableAsNull and type.treatNonObjectAsNull():
+ if not isDefinitelyObject:
+ haveObject = "${val}.isObject()"
+ if defaultValue is not None:
+ assert(isinstance(defaultValue, IDLNullValue))
+ haveObject = "${haveValue} && " + haveObject
+ template = CGIfElseWrapper(haveObject,
+ CGGeneric(conversion),
+ CGGeneric("${declName} = nullptr;\n")).define()
+ else:
+ template = conversion
+ else:
+ template = wrapObjectTemplate(
+ "if (JS::IsCallable(&${val}.toObject())) {\n" +
+ conversion +
+ "} else {\n" +
+ indent(onFailureNotCallable(failureCode).define()) +
+ "}\n",
+ type,
+ "${declName} = nullptr;\n",
+ failureCode)
+ return JSToNativeConversionInfo(template, declType=declType,
+ declArgs=declArgs,
+ dealWithOptional=isOptional)
+
+ if type.isAny():
+ assert not isEnforceRange and not isClamp
+
+ declArgs = None
+ if isMember in ("Variadic", "Sequence", "Dictionary", "MozMap"):
+ # Rooting is handled by the sequence and dictionary tracers.
+ declType = "JS::Value"
+ else:
+ assert not isMember
+ declType = "JS::Rooted<JS::Value>"
+ declArgs = "cx"
+
+ assert not isOptional
+ templateBody = "${declName} = ${val};\n"
+
+ # For JS-implemented APIs, we refuse to allow passing objects that the
+ # API consumer does not subsume. The extra parens around
+ # ($${passedToJSImpl}) suppress unreachable code warnings when
+ # $${passedToJSImpl} is the literal `false`.
+ if not isinstance(descriptorProvider, Descriptor) or descriptorProvider.interface.isJSImplemented():
+ templateBody = fill(
+ """
+ if (($${passedToJSImpl}) && !CallerSubsumes($${val})) {
+ ThrowErrorMessage(cx, MSG_PERMISSION_DENIED_TO_PASS_ARG, "${sourceDescription}");
+ $*{exceptionCode}
+ }
+ """,
+ sourceDescription=sourceDescription,
+ exceptionCode=exceptionCode) + templateBody
+
+ # We may not have a default value if we're being converted for
+ # a setter, say.
+ if defaultValue:
+ if isinstance(defaultValue, IDLNullValue):
+ defaultHandling = "${declName} = JS::NullValue();\n"
+ else:
+ assert isinstance(defaultValue, IDLUndefinedValue)
+ defaultHandling = "${declName} = JS::UndefinedValue();\n"
+ templateBody = handleDefault(templateBody, defaultHandling)
+ return JSToNativeConversionInfo(templateBody,
+ declType=CGGeneric(declType),
+ declArgs=declArgs)
+
+ if type.isObject():
+ assert not isEnforceRange and not isClamp
+ return handleJSObjectType(type, isMember, failureCode, exceptionCode, sourceDescription)
+
+ if type.isDictionary():
+ # There are no nullable dictionaries
+ assert not type.nullable() or isCallbackReturnValue
+ # All optional dictionaries always have default values, so we
+ # should be able to assume not isOptional here.
+ assert not isOptional
+ # In the callback return value case we never have to worry
+ # about a default value; we always have a value.
+ assert not isCallbackReturnValue or defaultValue is None
+
+ typeName = CGDictionary.makeDictionaryName(type.unroll().inner)
+ if not isMember and not isCallbackReturnValue:
+ # Since we're not a member and not nullable or optional, no one will
+ # see our real type, so we can do the fast version of the dictionary
+ # that doesn't pre-initialize members.
+ typeName = "binding_detail::Fast" + typeName
+
+ declType = CGGeneric(typeName)
+
+ # We do manual default value handling here, because we
+ # actually do want a jsval, and we only handle null anyway
+ # NOTE: if isNullOrUndefined or isDefinitelyObject are true,
+ # we know we have a value, so we don't have to worry about the
+ # default value.
+ if (not isNullOrUndefined and not isDefinitelyObject and
+ defaultValue is not None):
+ assert(isinstance(defaultValue, IDLNullValue))
+ val = "(${haveValue}) ? ${val} : JS::NullHandleValue"
+ else:
+ val = "${val}"
+
+ dictLoc = "${declName}"
+ if type.nullable():
+ dictLoc += ".SetValue()"
+
+ conversionCode = fill("""
+ if (!${dictLoc}.Init(cx, ${val}, "${desc}", $${passedToJSImpl})) {
+ $*{exceptionCode}
+ }
+ """,
+ dictLoc=dictLoc,
+ val=val,
+ desc=firstCap(sourceDescription),
+ exceptionCode=exceptionCode)
+
+ if failureCode is not None:
+ if isDefinitelyObject:
+ dictionaryTest = "IsObjectValueConvertibleToDictionary"
+ else:
+ dictionaryTest = "IsConvertibleToDictionary"
+
+ template = fill("""
+ { // scope for isConvertible
+ bool isConvertible;
+ if (!${testConvertible}(cx, ${val}, &isConvertible)) {
+ $*{exceptionCode}
+ }
+ if (!isConvertible) {
+ $*{failureCode}
+ }
+
+ $*{conversionCode}
+ }
+
+ """,
+ testConvertible=dictionaryTest,
+ val=val,
+ exceptionCode=exceptionCode,
+ failureCode=failureCode,
+ conversionCode=conversionCode)
+ else:
+ template = conversionCode
+
+ if type.nullable():
+ declType = CGTemplatedType("Nullable", declType)
+ template = CGIfElseWrapper("${val}.isNullOrUndefined()",
+ CGGeneric("${declName}.SetNull();\n"),
+ CGGeneric(template)).define()
+
+ # Dictionary arguments that might contain traceable things need to get
+ # traced
+ if not isMember and isCallbackReturnValue:
+ # Go ahead and just convert directly into our actual return value
+ declType = CGWrapper(declType, post="&")
+ declArgs = "aRetVal"
+ elif not isMember and typeNeedsRooting(type):
+ declType = CGTemplatedType("RootedDictionary", declType)
+ declArgs = "cx"
+ else:
+ declArgs = None
+
+ return JSToNativeConversionInfo(template, declType=declType,
+ declArgs=declArgs)
+
+ if type.isVoid():
+ assert not isOptional
+ # This one only happens for return values, and its easy: Just
+ # ignore the jsval.
+ return JSToNativeConversionInfo("")
+
+ if type.isDate():
+ assert not isEnforceRange and not isClamp
+
+ declType = CGGeneric("Date")
+ if type.nullable():
+ declType = CGTemplatedType("Nullable", declType)
+ dateVal = "${declName}.SetValue()"
+ else:
+ dateVal = "${declName}"
+
+ if failureCode is None:
+ notDate = ('ThrowErrorMessage(cx, MSG_NOT_DATE, "%s");\n'
+ "%s" % (firstCap(sourceDescription), exceptionCode))
+ else:
+ notDate = failureCode
+
+ conversion = fill(
+ """
+ JS::Rooted<JSObject*> possibleDateObject(cx, &$${val}.toObject());
+ { // scope for isDate
+ bool isDate;
+ if (!JS_ObjectIsDate(cx, possibleDateObject, &isDate)) {
+ $*{exceptionCode}
+ }
+ if (!isDate) {
+ $*{notDate}
+ }
+ if (!${dateVal}.SetTimeStamp(cx, possibleDateObject)) {
+ $*{exceptionCode}
+ }
+ }
+ """,
+ exceptionCode=exceptionCode,
+ dateVal=dateVal,
+ notDate=notDate)
+
+ conversion = wrapObjectTemplate(conversion, type,
+ "${declName}.SetNull();\n", notDate)
+ return JSToNativeConversionInfo(conversion,
+ declType=declType,
+ dealWithOptional=isOptional)
+
+ if not type.isPrimitive():
+ raise TypeError("Need conversion for argument type '%s'" % str(type))
+
+ typeName = builtinNames[type.tag()]
+
+ conversionBehavior = "eDefault"
+ if isEnforceRange:
+ assert type.isInteger()
+ conversionBehavior = "eEnforceRange"
+ elif isClamp:
+ assert type.isInteger()
+ conversionBehavior = "eClamp"
+
+ if type.nullable():
+ declType = CGGeneric("Nullable<" + typeName + ">")
+ writeLoc = "${declName}.SetValue()"
+ readLoc = "${declName}.Value()"
+ nullCondition = "${val}.isNullOrUndefined()"
+ if defaultValue is not None and isinstance(defaultValue, IDLNullValue):
+ nullCondition = "!(${haveValue}) || " + nullCondition
+ template = fill("""
+ if (${nullCondition}) {
+ $${declName}.SetNull();
+ } else if (!ValueToPrimitive<${typeName}, ${conversionBehavior}>(cx, $${val}, &${writeLoc})) {
+ $*{exceptionCode}
+ }
+ """,
+ nullCondition=nullCondition,
+ typeName=typeName,
+ conversionBehavior=conversionBehavior,
+ writeLoc=writeLoc,
+ exceptionCode=exceptionCode)
+ else:
+ assert(defaultValue is None or
+ not isinstance(defaultValue, IDLNullValue))
+ writeLoc = "${declName}"
+ readLoc = writeLoc
+ template = fill("""
+ if (!ValueToPrimitive<${typeName}, ${conversionBehavior}>(cx, $${val}, &${writeLoc})) {
+ $*{exceptionCode}
+ }
+ """,
+ typeName=typeName,
+ conversionBehavior=conversionBehavior,
+ writeLoc=writeLoc,
+ exceptionCode=exceptionCode)
+ declType = CGGeneric(typeName)
+
+ if type.isFloat() and not type.isUnrestricted():
+ if lenientFloatCode is not None:
+ nonFiniteCode = lenientFloatCode
+ else:
+ nonFiniteCode = ('ThrowErrorMessage(cx, MSG_NOT_FINITE, "%s");\n'
+ "%s" % (firstCap(sourceDescription), exceptionCode))
+
+ # We're appending to an if-block brace, so strip trailing whitespace
+ # and add an extra space before the else.
+ template = template.rstrip()
+ template += fill("""
+ else if (!mozilla::IsFinite(${readLoc})) {
+ $*{nonFiniteCode}
+ }
+ """,
+ readLoc=readLoc,
+ nonFiniteCode=nonFiniteCode)
+
+ if (defaultValue is not None and
+ # We already handled IDLNullValue, so just deal with the other ones
+ not isinstance(defaultValue, IDLNullValue)):
+ tag = defaultValue.type.tag()
+ defaultStr = getHandleDefault(defaultValue)
+ template = CGIfElseWrapper(
+ "${haveValue}",
+ CGGeneric(template),
+ CGGeneric("%s = %s;\n" % (writeLoc, defaultStr))).define()
+
+ return JSToNativeConversionInfo(template, declType=declType,
+ dealWithOptional=isOptional)
+
+
+def instantiateJSToNativeConversion(info, replacements, checkForValue=False):
+ """
+ Take a JSToNativeConversionInfo as returned by getJSToNativeConversionInfo
+ and a set of replacements as required by the strings in such an object, and
+ generate code to convert into stack C++ types.
+
+ If checkForValue is True, then the conversion will get wrapped in
+ a check for ${haveValue}.
+ """
+ templateBody, declType, holderType, dealWithOptional = (
+ info.template, info.declType, info.holderType, info.dealWithOptional)
+
+ if dealWithOptional and not checkForValue:
+ raise TypeError("Have to deal with optional things, but don't know how")
+ if checkForValue and declType is None:
+ raise TypeError("Need to predeclare optional things, so they will be "
+ "outside the check for big enough arg count!")
+
+ # We can't precompute our holder constructor arguments, since
+ # those might depend on ${declName}, which we change below. Just
+ # compute arguments at the point when we need them as we go.
+ def getArgsCGThing(args):
+ return CGGeneric(string.Template(args).substitute(replacements))
+
+ result = CGList([])
+ # Make a copy of "replacements" since we may be about to start modifying it
+ replacements = dict(replacements)
+ originalDeclName = replacements["declName"]
+ if declType is not None:
+ if dealWithOptional:
+ replacements["declName"] = "%s.Value()" % originalDeclName
+ declType = CGTemplatedType("Optional", declType)
+ declCtorArgs = None
+ elif info.declArgs is not None:
+ declCtorArgs = CGWrapper(getArgsCGThing(info.declArgs),
+ pre="(", post=")")
+ else:
+ declCtorArgs = None
+ result.append(
+ CGList([declType, CGGeneric(" "),
+ CGGeneric(originalDeclName),
+ declCtorArgs, CGGeneric(";\n")]))
+
+ originalHolderName = replacements["holderName"]
+ if holderType is not None:
+ if dealWithOptional:
+ replacements["holderName"] = "%s.ref()" % originalHolderName
+ holderType = CGTemplatedType("Maybe", holderType)
+ holderCtorArgs = None
+ elif info.holderArgs is not None:
+ holderCtorArgs = CGWrapper(getArgsCGThing(info.holderArgs),
+ pre="(", post=")")
+ else:
+ holderCtorArgs = None
+ result.append(
+ CGList([holderType, CGGeneric(" "),
+ CGGeneric(originalHolderName),
+ holderCtorArgs, CGGeneric(";\n")]))
+
+ if "maybeMutableVal" not in replacements:
+ replacements["maybeMutableVal"] = replacements["val"]
+
+ conversion = CGGeneric(
+ string.Template(templateBody).substitute(replacements))
+
+ if checkForValue:
+ if dealWithOptional:
+ declConstruct = CGIndenter(
+ CGGeneric("%s.Construct(%s);\n" %
+ (originalDeclName,
+ getArgsCGThing(info.declArgs).define() if
+ info.declArgs else "")))
+ if holderType is not None:
+ holderConstruct = CGIndenter(
+ CGGeneric("%s.emplace(%s);\n" %
+ (originalHolderName,
+ getArgsCGThing(info.holderArgs).define() if
+ info.holderArgs else "")))
+ else:
+ holderConstruct = None
+ else:
+ declConstruct = None
+ holderConstruct = None
+
+ conversion = CGList([
+ CGGeneric(
+ string.Template("if (${haveValue}) {\n").substitute(replacements)),
+ declConstruct,
+ holderConstruct,
+ CGIndenter(conversion),
+ CGGeneric("}\n")
+ ])
+
+ result.append(conversion)
+ return result
+
+
+def convertConstIDLValueToJSVal(value):
+ if isinstance(value, IDLNullValue):
+ return "JS::NullValue()"
+ if isinstance(value, IDLUndefinedValue):
+ return "JS::UndefinedValue()"
+ tag = value.type.tag()
+ if tag in [IDLType.Tags.int8, IDLType.Tags.uint8, IDLType.Tags.int16,
+ IDLType.Tags.uint16, IDLType.Tags.int32]:
+ return "JS::Int32Value(%s)" % (value.value)
+ if tag == IDLType.Tags.uint32:
+ return "JS::NumberValue(%sU)" % (value.value)
+ if tag in [IDLType.Tags.int64, IDLType.Tags.uint64]:
+ return "JS::CanonicalizedDoubleValue(%s)" % numericValue(tag, value.value)
+ if tag == IDLType.Tags.bool:
+ return "JS::BooleanValue(true)" if value.value else "JS::BooleanValue(false)"
+ if tag in [IDLType.Tags.float, IDLType.Tags.double]:
+ return "JS::CanonicalizedDoubleValue(%s)" % (value.value)
+ raise TypeError("Const value of unhandled type: %s" % value.type)
+
+
+class CGArgumentConverter(CGThing):
+ """
+ A class that takes an IDL argument object and its index in the
+ argument list and generates code to unwrap the argument to the
+ right native type.
+
+ argDescription is a description of the argument for error-reporting
+ purposes. Callers should assume that it might get placed in the middle of a
+ sentence. If it ends up at the beginning of a sentence, its first character
+ will be automatically uppercased.
+ """
+ def __init__(self, argument, index, descriptorProvider,
+ argDescription, member,
+ invalidEnumValueFatal=True, lenientFloatCode=None):
+ CGThing.__init__(self)
+ self.argument = argument
+ self.argDescription = argDescription
+ assert(not argument.defaultValue or argument.optional)
+
+ replacer = {
+ "index": index,
+ "argc": "args.length()"
+ }
+ self.replacementVariables = {
+ "declName": "arg%d" % index,
+ "holderName": ("arg%d" % index) + "_holder",
+ "obj": "obj",
+ "passedToJSImpl": toStringBool(isJSImplementedDescriptor(descriptorProvider))
+ }
+ # If we have a method generated by the maplike/setlike portion of an
+ # interface, arguments can possibly be undefined, but will need to be
+ # converted to the key/value type of the backing object. In this case,
+ # use .get() instead of direct access to the argument. This won't
+ # matter for iterable since generated functions for those interface
+ # don't take arguments.
+ if member.isMethod() and member.isMaplikeOrSetlikeOrIterableMethod():
+ self.replacementVariables["val"] = string.Template(
+ "args.get(${index})").substitute(replacer)
+ self.replacementVariables["maybeMutableVal"] = string.Template(
+ "args[${index}]").substitute(replacer)
+ else:
+ self.replacementVariables["val"] = string.Template(
+ "args[${index}]").substitute(replacer)
+ haveValueCheck = string.Template(
+ "args.hasDefined(${index})").substitute(replacer)
+ self.replacementVariables["haveValue"] = haveValueCheck
+ self.descriptorProvider = descriptorProvider
+ if self.argument.canHaveMissingValue():
+ self.argcAndIndex = replacer
+ else:
+ self.argcAndIndex = None
+ self.invalidEnumValueFatal = invalidEnumValueFatal
+ self.lenientFloatCode = lenientFloatCode
+
+ def define(self):
+ typeConversion = getJSToNativeConversionInfo(
+ self.argument.type,
+ self.descriptorProvider,
+ isOptional=(self.argcAndIndex is not None and
+ not self.argument.variadic),
+ invalidEnumValueFatal=self.invalidEnumValueFatal,
+ defaultValue=self.argument.defaultValue,
+ treatNullAs=self.argument.treatNullAs,
+ isEnforceRange=self.argument.enforceRange,
+ isClamp=self.argument.clamp,
+ lenientFloatCode=self.lenientFloatCode,
+ isMember="Variadic" if self.argument.variadic else False,
+ allowTreatNonCallableAsNull=self.argument.allowTreatNonCallableAsNull(),
+ sourceDescription=self.argDescription)
+
+ if not self.argument.variadic:
+ return instantiateJSToNativeConversion(
+ typeConversion,
+ self.replacementVariables,
+ self.argcAndIndex is not None).define()
+
+ # Variadic arguments get turned into a sequence.
+ if typeConversion.dealWithOptional:
+ raise TypeError("Shouldn't have optional things in variadics")
+ if typeConversion.holderType is not None:
+ raise TypeError("Shouldn't need holders for variadics")
+
+ replacer = dict(self.argcAndIndex, **self.replacementVariables)
+ replacer["seqType"] = CGTemplatedType("binding_detail::AutoSequence",
+ typeConversion.declType).define()
+ if typeNeedsRooting(self.argument.type):
+ rooterDecl = ("SequenceRooter<%s> ${holderName}(cx, &${declName});\n" %
+ typeConversion.declType.define())
+ else:
+ rooterDecl = ""
+ replacer["elemType"] = typeConversion.declType.define()
+
+ # NOTE: Keep this in sync with sequence conversions as needed
+ variadicConversion = string.Template(
+ "${seqType} ${declName};\n" +
+ rooterDecl +
+ dedent("""
+ if (${argc} > ${index}) {
+ if (!${declName}.SetCapacity(${argc} - ${index}, mozilla::fallible)) {
+ JS_ReportOutOfMemory(cx);
+ return false;
+ }
+ for (uint32_t variadicArg = ${index}; variadicArg < ${argc}; ++variadicArg) {
+ ${elemType}& slot = *${declName}.AppendElement(mozilla::fallible);
+ """)
+ ).substitute(replacer)
+
+ val = string.Template("args[variadicArg]").substitute(replacer)
+ variadicConversion += indent(
+ string.Template(typeConversion.template).substitute({
+ "val": val,
+ "maybeMutableVal": val,
+ "declName": "slot",
+ # We only need holderName here to handle isExternal()
+ # interfaces, which use an internal holder for the
+ # conversion even when forceOwningType ends up true.
+ "holderName": "tempHolder",
+ # Use the same ${obj} as for the variadic arg itself
+ "obj": replacer["obj"],
+ "passedToJSImpl": toStringBool(isJSImplementedDescriptor(self.descriptorProvider))
+ }), 4)
+
+ variadicConversion += (" }\n"
+ "}\n")
+ return variadicConversion
+
+
+def getMaybeWrapValueFuncForType(type):
+ # Callbacks might actually be DOM objects; nothing prevents a page from
+ # doing that.
+ if type.isCallback() or type.isCallbackInterface() or type.isObject():
+ if type.nullable():
+ return "MaybeWrapObjectOrNullValue"
+ return "MaybeWrapObjectValue"
+ # Spidermonkey interfaces are never DOM objects. Neither are sequences or
+ # dictionaries, since those are always plain JS objects.
+ if type.isSpiderMonkeyInterface() or type.isDictionary() or type.isSequence():
+ if type.nullable():
+ return "MaybeWrapNonDOMObjectOrNullValue"
+ return "MaybeWrapNonDOMObjectValue"
+ if type.isAny():
+ return "MaybeWrapValue"
+
+ # For other types, just go ahead an fall back on MaybeWrapValue for now:
+ # it's always safe to do, and shouldn't be particularly slow for any of
+ # them
+ return "MaybeWrapValue"
+
+
+sequenceWrapLevel = 0
+mozMapWrapLevel = 0
+
+
+def getWrapTemplateForType(type, descriptorProvider, result, successCode,
+ returnsNewObject, exceptionCode, typedArraysAreStructs,
+ isConstructorRetval=False):
+ """
+ Reflect a C++ value stored in "result", of IDL type "type" into JS. The
+ "successCode" is the code to run once we have successfully done the
+ conversion and must guarantee that execution of the conversion template
+ stops once the successCode has executed (e.g. by doing a 'return', or by
+ doing a 'break' if the entire conversion template is inside a block that
+ the 'break' will exit).
+
+ If typedArraysAreStructs is true, then if the type is a typed array,
+ "result" is one of the dom::TypedArray subclasses, not a JSObject*.
+
+ The resulting string should be used with string.Template. It
+ needs the following keys when substituting:
+
+ jsvalHandle: something that can be passed to methods taking a
+ JS::MutableHandle<JS::Value>. This can be a
+ JS::MutableHandle<JS::Value> or a JS::Rooted<JS::Value>*.
+ jsvalRef: something that can have .address() called on it to get a
+ JS::Value* and .set() called on it to set it to a JS::Value.
+ This can be a JS::MutableHandle<JS::Value> or a
+ JS::Rooted<JS::Value>.
+ obj: a JS::Handle<JSObject*>.
+
+ Returns (templateString, infallibility of conversion template)
+ """
+ if successCode is None:
+ successCode = "return true;\n"
+
+ def setUndefined():
+ return _setValue("", setter="setUndefined")
+
+ def setNull():
+ return _setValue("", setter="setNull")
+
+ def setInt32(value):
+ return _setValue(value, setter="setInt32")
+
+ def setString(value):
+ return _setValue(value, setter="setString")
+
+ def setObject(value, wrapAsType=None):
+ return _setValue(value, wrapAsType=wrapAsType, setter="setObject")
+
+ def setObjectOrNull(value, wrapAsType=None):
+ return _setValue(value, wrapAsType=wrapAsType, setter="setObjectOrNull")
+
+ def setUint32(value):
+ return _setValue(value, setter="setNumber")
+
+ def setDouble(value):
+ return _setValue("JS_NumberValue(%s)" % value)
+
+ def setBoolean(value):
+ return _setValue(value, setter="setBoolean")
+
+ def _setValue(value, wrapAsType=None, setter="set"):
+ """
+ Returns the code to set the jsval to value.
+
+ If wrapAsType is not None, then will wrap the resulting value using the
+ function that getMaybeWrapValueFuncForType(wrapAsType) returns.
+ Otherwise, no wrapping will be done.
+ """
+ if wrapAsType is None:
+ tail = successCode
+ else:
+ tail = fill(
+ """
+ if (!${maybeWrap}(cx, $${jsvalHandle})) {
+ $*{exceptionCode}
+ }
+ $*{successCode}
+ """,
+ maybeWrap=getMaybeWrapValueFuncForType(wrapAsType),
+ exceptionCode=exceptionCode,
+ successCode=successCode)
+ return ("${jsvalRef}.%s(%s);\n" % (setter, value)) + tail
+
+ def wrapAndSetPtr(wrapCall, failureCode=None):
+ """
+ Returns the code to set the jsval by calling "wrapCall". "failureCode"
+ is the code to run if calling "wrapCall" fails
+ """
+ if failureCode is None:
+ failureCode = exceptionCode
+ return fill(
+ """
+ if (!${wrapCall}) {
+ $*{failureCode}
+ }
+ $*{successCode}
+ """,
+ wrapCall=wrapCall,
+ failureCode=failureCode,
+ successCode=successCode)
+
+ if type is None or type.isVoid():
+ return (setUndefined(), True)
+
+ if (type.isSequence() or type.isMozMap()) and type.nullable():
+ # These are both wrapped in Nullable<>
+ recTemplate, recInfall = getWrapTemplateForType(type.inner, descriptorProvider,
+ "%s.Value()" % result, successCode,
+ returnsNewObject, exceptionCode,
+ typedArraysAreStructs)
+ code = fill(
+ """
+
+ if (${result}.IsNull()) {
+ $*{setNull}
+ }
+ $*{recTemplate}
+ """,
+ result=result,
+ setNull=setNull(),
+ recTemplate=recTemplate)
+ return code, recInfall
+
+ if type.isSequence():
+ # Now do non-nullable sequences. Our success code is just to break to
+ # where we set the element in the array. Note that we bump the
+ # sequenceWrapLevel around this call so that nested sequence conversions
+ # will use different iteration variables.
+ global sequenceWrapLevel
+ index = "sequenceIdx%d" % sequenceWrapLevel
+ sequenceWrapLevel += 1
+ innerTemplate = wrapForType(
+ type.inner, descriptorProvider,
+ {
+ 'result': "%s[%s]" % (result, index),
+ 'successCode': "break;\n",
+ 'jsvalRef': "tmp",
+ 'jsvalHandle': "&tmp",
+ 'returnsNewObject': returnsNewObject,
+ 'exceptionCode': exceptionCode,
+ 'obj': "returnArray",
+ 'typedArraysAreStructs': typedArraysAreStructs
+ })
+ sequenceWrapLevel -= 1
+ code = fill(
+ """
+
+ uint32_t length = ${result}.Length();
+ JS::Rooted<JSObject*> returnArray(cx, JS_NewArrayObject(cx, length));
+ if (!returnArray) {
+ $*{exceptionCode}
+ }
+ // Scope for 'tmp'
+ {
+ JS::Rooted<JS::Value> tmp(cx);
+ for (uint32_t ${index} = 0; ${index} < length; ++${index}) {
+ // Control block to let us common up the JS_DefineElement calls when there
+ // are different ways to succeed at wrapping the object.
+ do {
+ $*{innerTemplate}
+ } while (0);
+ if (!JS_DefineElement(cx, returnArray, ${index}, tmp,
+ JSPROP_ENUMERATE)) {
+ $*{exceptionCode}
+ }
+ }
+ }
+ $*{set}
+ """,
+ result=result,
+ exceptionCode=exceptionCode,
+ index=index,
+ innerTemplate=innerTemplate,
+ set=setObject("*returnArray"))
+
+ return (code, False)
+
+ if type.isMozMap():
+ # Now do non-nullable MozMap. Our success code is just to break to
+ # where we define the property on the object. Note that we bump the
+ # mozMapWrapLevel around this call so that nested MozMap conversions
+ # will use different temp value names.
+ global mozMapWrapLevel
+ valueName = "mozMapValue%d" % mozMapWrapLevel
+ mozMapWrapLevel += 1
+ innerTemplate = wrapForType(
+ type.inner, descriptorProvider,
+ {
+ 'result': valueName,
+ 'successCode': "break;\n",
+ 'jsvalRef': "tmp",
+ 'jsvalHandle': "&tmp",
+ 'returnsNewObject': returnsNewObject,
+ 'exceptionCode': exceptionCode,
+ 'obj': "returnObj",
+ 'typedArraysAreStructs': typedArraysAreStructs
+ })
+ mozMapWrapLevel -= 1
+ code = fill(
+ """
+
+ nsTArray<nsString> keys;
+ ${result}.GetKeys(keys);
+ JS::Rooted<JSObject*> returnObj(cx, JS_NewPlainObject(cx));
+ if (!returnObj) {
+ $*{exceptionCode}
+ }
+ // Scope for 'tmp'
+ {
+ JS::Rooted<JS::Value> tmp(cx);
+ for (size_t idx = 0; idx < keys.Length(); ++idx) {
+ auto& ${valueName} = ${result}.Get(keys[idx]);
+ // Control block to let us common up the JS_DefineUCProperty calls when there
+ // are different ways to succeed at wrapping the value.
+ do {
+ $*{innerTemplate}
+ } while (0);
+ if (!JS_DefineUCProperty(cx, returnObj, keys[idx].get(),
+ keys[idx].Length(), tmp,
+ JSPROP_ENUMERATE)) {
+ $*{exceptionCode}
+ }
+ }
+ }
+ $*{set}
+ """,
+ result=result,
+ exceptionCode=exceptionCode,
+ valueName=valueName,
+ innerTemplate=innerTemplate,
+ set=setObject("*returnObj"))
+
+ return (code, False)
+
+ if type.isGeckoInterface() and not type.isCallbackInterface():
+ descriptor = descriptorProvider.getDescriptor(type.unroll().inner.identifier.name)
+ if type.nullable():
+ wrappingCode = ("if (!%s) {\n" % (result) +
+ indent(setNull()) +
+ "}\n")
+ else:
+ wrappingCode = ""
+
+ if not descriptor.interface.isExternal():
+ if descriptor.wrapperCache:
+ wrapMethod = "GetOrCreateDOMReflector"
+ wrapArgs = "cx, %s, ${jsvalHandle}" % result
+ else:
+ # Hack: the "Promise" interface is OK to return from
+ # non-newobject things even when it's not wrappercached; that
+ # happens when using SpiderMonkey promises, and the WrapObject()
+ # method will just return the existing reflector, which is just
+ # not stored in a wrappercache.
+ if (not returnsNewObject and
+ descriptor.interface.identifier.name != "Promise"):
+ raise MethodNotNewObjectError(descriptor.interface.identifier.name)
+ wrapMethod = "WrapNewBindingNonWrapperCachedObject"
+ wrapArgs = "cx, ${obj}, %s, ${jsvalHandle}" % result
+ if isConstructorRetval:
+ wrapArgs += ", desiredProto"
+ wrap = "%s(%s)" % (wrapMethod, wrapArgs)
+ if not descriptor.hasXPConnectImpls:
+ # Can only fail to wrap as a new-binding object
+ # if they already threw an exception.
+ # XXX Assertion disabled for now, see bug 991271.
+ failed = ("MOZ_ASSERT(true || JS_IsExceptionPending(cx));\n" +
+ exceptionCode)
+ else:
+ if descriptor.notflattened:
+ raise TypeError("%s has XPConnect impls but not flattened; "
+ "fallback won't work correctly" %
+ descriptor.interface.identifier.name)
+ # Try old-style wrapping for bindings which might be XPConnect impls.
+ failed = wrapAndSetPtr("HandleNewBindingWrappingFailure(cx, ${obj}, %s, ${jsvalHandle})" % result)
+ else:
+ if descriptor.notflattened:
+ getIID = "&NS_GET_IID(%s), " % descriptor.nativeType
+ else:
+ getIID = ""
+ wrap = "WrapObject(cx, %s, %s${jsvalHandle})" % (result, getIID)
+ failed = None
+
+ wrappingCode += wrapAndSetPtr(wrap, failed)
+ return (wrappingCode, False)
+
+ if type.isDOMString() or type.isUSVString():
+ if type.nullable():
+ return (wrapAndSetPtr("xpc::StringToJsval(cx, %s, ${jsvalHandle})" % result), False)
+ else:
+ return (wrapAndSetPtr("xpc::NonVoidStringToJsval(cx, %s, ${jsvalHandle})" % result), False)
+
+ if type.isByteString():
+ if type.nullable():
+ return (wrapAndSetPtr("ByteStringToJsval(cx, %s, ${jsvalHandle})" % result), False)
+ else:
+ return (wrapAndSetPtr("NonVoidByteStringToJsval(cx, %s, ${jsvalHandle})" % result), False)
+
+ if type.isEnum():
+ if type.nullable():
+ resultLoc = "%s.Value()" % result
+ else:
+ resultLoc = result
+ conversion = fill(
+ """
+ if (!ToJSValue(cx, ${result}, $${jsvalHandle})) {
+ $*{exceptionCode}
+ }
+ $*{successCode}
+ """,
+ result=resultLoc,
+ exceptionCode=exceptionCode,
+ successCode=successCode)
+
+ if type.nullable():
+ conversion = CGIfElseWrapper(
+ "%s.IsNull()" % result,
+ CGGeneric(setNull()),
+ CGGeneric(conversion)).define()
+ return conversion, False
+
+ if type.isCallback() or type.isCallbackInterface():
+ wrapCode = setObject(
+ "*GetCallbackFromCallbackObject(%(result)s)",
+ wrapAsType=type)
+ if type.nullable():
+ wrapCode = (
+ "if (%(result)s) {\n" +
+ indent(wrapCode) +
+ "} else {\n" +
+ indent(setNull()) +
+ "}\n")
+ wrapCode = wrapCode % {"result": result}
+ return wrapCode, False
+
+ if type.isAny():
+ # See comments in GetOrCreateDOMReflector explaining why we need
+ # to wrap here.
+ # NB: _setValue(..., type-that-is-any) calls JS_WrapValue(), so is fallible
+ head = "JS::ExposeValueToActiveJS(%s);\n" % result
+ return (head + _setValue(result, wrapAsType=type), False)
+
+ if (type.isObject() or (type.isSpiderMonkeyInterface() and
+ not typedArraysAreStructs)):
+ # See comments in GetOrCreateDOMReflector explaining why we need
+ # to wrap here.
+ if type.nullable():
+ toValue = "%s"
+ setter = setObjectOrNull
+ head = """if (%s) {
+ JS::ExposeObjectToActiveJS(%s);
+ }
+ """ % (result, result)
+ else:
+ toValue = "*%s"
+ setter = setObject
+ head = "JS::ExposeObjectToActiveJS(%s);\n" % result
+ # NB: setObject{,OrNull}(..., some-object-type) calls JS_WrapValue(), so is fallible
+ return (head + setter(toValue % result, wrapAsType=type), False)
+
+ if not (type.isUnion() or type.isPrimitive() or type.isDictionary() or
+ type.isDate() or
+ (type.isSpiderMonkeyInterface() and typedArraysAreStructs)):
+ raise TypeError("Need to learn to wrap %s" % type)
+
+ if type.nullable():
+ recTemplate, recInfal = getWrapTemplateForType(type.inner, descriptorProvider,
+ "%s.Value()" % result, successCode,
+ returnsNewObject, exceptionCode,
+ typedArraysAreStructs)
+ return ("if (%s.IsNull()) {\n" % result +
+ indent(setNull()) +
+ "}\n" +
+ recTemplate, recInfal)
+
+ if type.isSpiderMonkeyInterface():
+ assert typedArraysAreStructs
+ # See comments in GetOrCreateDOMReflector explaining why we need
+ # to wrap here.
+ # NB: setObject(..., some-object-type) calls JS_WrapValue(), so is fallible
+ return (setObject("*%s.Obj()" % result,
+ wrapAsType=type), False)
+
+ if type.isUnion():
+ return (wrapAndSetPtr("%s.ToJSVal(cx, ${obj}, ${jsvalHandle})" % result),
+ False)
+
+ if type.isDictionary():
+ return (wrapAndSetPtr("%s.ToObjectInternal(cx, ${jsvalHandle})" % result),
+ False)
+
+ if type.isDate():
+ return (wrapAndSetPtr("%s.ToDateObject(cx, ${jsvalHandle})" % result),
+ False)
+
+ tag = type.tag()
+
+ if tag in [IDLType.Tags.int8, IDLType.Tags.uint8, IDLType.Tags.int16,
+ IDLType.Tags.uint16, IDLType.Tags.int32]:
+ return (setInt32("int32_t(%s)" % result), True)
+
+ elif tag in [IDLType.Tags.int64, IDLType.Tags.uint64,
+ IDLType.Tags.unrestricted_float, IDLType.Tags.float,
+ IDLType.Tags.unrestricted_double, IDLType.Tags.double]:
+ # XXXbz will cast to double do the "even significand" thing that webidl
+ # calls for for 64-bit ints? Do we care?
+ return (setDouble("double(%s)" % result), True)
+
+ elif tag == IDLType.Tags.uint32:
+ return (setUint32(result), True)
+
+ elif tag == IDLType.Tags.bool:
+ return (setBoolean(result), True)
+
+ else:
+ raise TypeError("Need to learn to wrap primitive: %s" % type)
+
+
+def wrapForType(type, descriptorProvider, templateValues):
+ """
+ Reflect a C++ value of IDL type "type" into JS. TemplateValues is a dict
+ that should contain:
+
+ * 'jsvalRef': something that can have .address() called on it to get a
+ JS::Value* and .set() called on it to set it to a JS::Value.
+ This can be a JS::MutableHandle<JS::Value> or a
+ JS::Rooted<JS::Value>.
+ * 'jsvalHandle': something that can be passed to methods taking a
+ JS::MutableHandle<JS::Value>. This can be a
+ JS::MutableHandle<JS::Value> or a JS::Rooted<JS::Value>*.
+ * 'obj' (optional): the name of the variable that contains the JSObject to
+ use as a scope when wrapping, if not supplied 'obj'
+ will be used as the name
+ * 'result' (optional): the name of the variable in which the C++ value is
+ stored, if not supplied 'result' will be used as
+ the name
+ * 'successCode' (optional): the code to run once we have successfully
+ done the conversion, if not supplied 'return
+ true;' will be used as the code. The
+ successCode must ensure that once it runs no
+ more of the conversion template will be
+ executed (e.g. by doing a 'return' or 'break'
+ as appropriate).
+ * 'returnsNewObject' (optional): If true, we're wrapping for the return
+ value of a [NewObject] method. Assumed
+ false if not set.
+ * 'exceptionCode' (optional): Code to run when a JS exception is thrown.
+ The default is "return false;". The code
+ passed here must return.
+ * 'isConstructorRetval' (optional): If true, we're wrapping a constructor
+ return value.
+ """
+ wrap = getWrapTemplateForType(
+ type, descriptorProvider,
+ templateValues.get('result', 'result'),
+ templateValues.get('successCode', None),
+ templateValues.get('returnsNewObject', False),
+ templateValues.get('exceptionCode', "return false;\n"),
+ templateValues.get('typedArraysAreStructs', False),
+ isConstructorRetval=templateValues.get('isConstructorRetval', False))[0]
+
+ defaultValues = {'obj': 'obj'}
+ return string.Template(wrap).substitute(defaultValues, **templateValues)
+
+
+def infallibleForMember(member, type, descriptorProvider):
+ """
+ Determine the fallibility of changing a C++ value of IDL type "type" into
+ JS for the given attribute. Apart from returnsNewObject, all the defaults
+ are used, since the fallbility does not change based on the boolean values,
+ and the template will be discarded.
+
+ CURRENT ASSUMPTIONS:
+ We assume that successCode for wrapping up return values cannot contain
+ failure conditions.
+ """
+ return getWrapTemplateForType(type, descriptorProvider, 'result', None,
+ memberReturnsNewObject(member), "return false;\n",
+ False)[1]
+
+
+def leafTypeNeedsCx(type, retVal):
+ return (type.isAny() or type.isObject() or
+ (retVal and type.isSpiderMonkeyInterface()))
+
+
+def leafTypeNeedsScopeObject(type, retVal):
+ return retVal and type.isSpiderMonkeyInterface()
+
+
+def leafTypeNeedsRooting(type):
+ return leafTypeNeedsCx(type, False) or type.isSpiderMonkeyInterface()
+
+
+def typeNeedsRooting(type):
+ return typeMatchesLambda(type,
+ lambda t: leafTypeNeedsRooting(t))
+
+
+def typeNeedsCx(type, retVal=False):
+ return typeMatchesLambda(type,
+ lambda t: leafTypeNeedsCx(t, retVal))
+
+
+def typeNeedsScopeObject(type, retVal=False):
+ return typeMatchesLambda(type,
+ lambda t: leafTypeNeedsScopeObject(t, retVal))
+
+
+def typeMatchesLambda(type, func):
+ if type is None:
+ return False
+ if type.nullable():
+ return typeMatchesLambda(type.inner, func)
+ if type.isSequence() or type.isMozMap():
+ return typeMatchesLambda(type.inner, func)
+ if type.isUnion():
+ return any(typeMatchesLambda(t, func) for t in
+ type.unroll().flatMemberTypes)
+ if type.isDictionary():
+ return dictionaryMatchesLambda(type.inner, func)
+ return func(type)
+
+
+def dictionaryMatchesLambda(dictionary, func):
+ return (any(typeMatchesLambda(m.type, func) for m in dictionary.members) or
+ (dictionary.parent and dictionaryMatchesLambda(dictionary.parent, func)))
+
+
+# Whenever this is modified, please update CGNativeMember.getRetvalInfo as
+# needed to keep the types compatible.
+def getRetvalDeclarationForType(returnType, descriptorProvider,
+ isMember=False):
+ """
+ Returns a tuple containing five things:
+
+ 1) A CGThing for the type of the return value, or None if there is no need
+ for a return value.
+
+ 2) A value indicating the kind of ourparam to pass the value as. Valid
+ options are None to not pass as an out param at all, "ref" (to pass a
+ reference as an out param), and "ptr" (to pass a pointer as an out
+ param).
+
+ 3) A CGThing for a tracer for the return value, or None if no tracing is
+ needed.
+
+ 4) An argument string to pass to the retval declaration
+ constructor or None if there are no arguments.
+
+ 5) The name of a function that needs to be called with the return value
+ before using it, or None if no function needs to be called.
+ """
+ if returnType is None or returnType.isVoid():
+ # Nothing to declare
+ return None, None, None, None, None
+ if returnType.isPrimitive() and returnType.tag() in builtinNames:
+ result = CGGeneric(builtinNames[returnType.tag()])
+ if returnType.nullable():
+ result = CGTemplatedType("Nullable", result)
+ return result, None, None, None, None
+ if returnType.isDOMString() or returnType.isUSVString():
+ if isMember:
+ return CGGeneric("nsString"), "ref", None, None, None
+ return CGGeneric("DOMString"), "ref", None, None, None
+ if returnType.isByteString():
+ return CGGeneric("nsCString"), "ref", None, None, None
+ if returnType.isEnum():
+ result = CGGeneric(returnType.unroll().inner.identifier.name)
+ if returnType.nullable():
+ result = CGTemplatedType("Nullable", result)
+ return result, None, None, None, None
+ if returnType.isGeckoInterface():
+ result = CGGeneric(descriptorProvider.getDescriptor(
+ returnType.unroll().inner.identifier.name).nativeType)
+ conversion = None
+ if isMember:
+ result = CGGeneric("StrongPtrForMember<%s>::Type" % result.define())
+ else:
+ conversion = CGGeneric("StrongOrRawPtr<%s>" % result.define())
+ result = CGGeneric("auto")
+ return result, None, None, None, conversion
+ if returnType.isCallback():
+ name = returnType.unroll().callback.identifier.name
+ return CGGeneric("RefPtr<%s>" % name), None, None, None, None
+ if returnType.isAny():
+ if isMember:
+ return CGGeneric("JS::Value"), None, None, None, None
+ return CGGeneric("JS::Rooted<JS::Value>"), "ptr", None, "cx", None
+ if returnType.isObject() or returnType.isSpiderMonkeyInterface():
+ if isMember:
+ return CGGeneric("JSObject*"), None, None, None, None
+ return CGGeneric("JS::Rooted<JSObject*>"), "ptr", None, "cx", None
+ if returnType.isSequence():
+ nullable = returnType.nullable()
+ if nullable:
+ returnType = returnType.inner
+ result, _, _, _, _ = getRetvalDeclarationForType(returnType.inner,
+ descriptorProvider,
+ isMember="Sequence")
+ # While we have our inner type, set up our rooter, if needed
+ if not isMember and typeNeedsRooting(returnType):
+ rooter = CGGeneric("SequenceRooter<%s > resultRooter(cx, &result);\n" %
+ result.define())
+ else:
+ rooter = None
+ result = CGTemplatedType("nsTArray", result)
+ if nullable:
+ result = CGTemplatedType("Nullable", result)
+ return result, "ref", rooter, None, None
+ if returnType.isMozMap():
+ nullable = returnType.nullable()
+ if nullable:
+ returnType = returnType.inner
+ result, _, _, _, _ = getRetvalDeclarationForType(returnType.inner,
+ descriptorProvider,
+ isMember="MozMap")
+ # While we have our inner type, set up our rooter, if needed
+ if not isMember and typeNeedsRooting(returnType):
+ rooter = CGGeneric("MozMapRooter<%s> resultRooter(cx, &result);\n" %
+ result.define())
+ else:
+ rooter = None
+ result = CGTemplatedType("MozMap", result)
+ if nullable:
+ result = CGTemplatedType("Nullable", result)
+ return result, "ref", rooter, None, None
+ if returnType.isDictionary():
+ nullable = returnType.nullable()
+ dictName = CGDictionary.makeDictionaryName(returnType.unroll().inner)
+ result = CGGeneric(dictName)
+ if not isMember and typeNeedsRooting(returnType):
+ if nullable:
+ result = CGTemplatedType("NullableRootedDictionary", result)
+ else:
+ result = CGTemplatedType("RootedDictionary", result)
+ resultArgs = "cx"
+ else:
+ if nullable:
+ result = CGTemplatedType("Nullable", result)
+ resultArgs = None
+ return result, "ref", None, resultArgs, None
+ if returnType.isUnion():
+ result = CGGeneric(CGUnionStruct.unionTypeName(returnType.unroll(), True))
+ if not isMember and typeNeedsRooting(returnType):
+ if returnType.nullable():
+ result = CGTemplatedType("NullableRootedUnion", result)
+ else:
+ result = CGTemplatedType("RootedUnion", result)
+ resultArgs = "cx"
+ else:
+ if returnType.nullable():
+ result = CGTemplatedType("Nullable", result)
+ resultArgs = None
+ return result, "ref", None, resultArgs, None
+ if returnType.isDate():
+ result = CGGeneric("Date")
+ if returnType.nullable():
+ result = CGTemplatedType("Nullable", result)
+ return result, None, None, None, None
+ raise TypeError("Don't know how to declare return value for %s" %
+ returnType)
+
+
+def needCx(returnType, arguments, extendedAttributes, considerTypes,
+ static=False):
+ return (not static and considerTypes and
+ (typeNeedsCx(returnType, True) or
+ any(typeNeedsCx(a.type) for a in arguments)) or
+ 'implicitJSContext' in extendedAttributes)
+
+
+def needScopeObject(returnType, arguments, extendedAttributes,
+ isWrapperCached, considerTypes, isMember):
+ """
+ isMember should be true if we're dealing with an attribute
+ annotated as [StoreInSlot].
+ """
+ return (considerTypes and not isWrapperCached and
+ ((not isMember and typeNeedsScopeObject(returnType, True)) or
+ any(typeNeedsScopeObject(a.type) for a in arguments)))
+
+
+class CGCallGenerator(CGThing):
+ """
+ A class to generate an actual call to a C++ object. Assumes that the C++
+ object is stored in a variable whose name is given by the |object| argument.
+
+ needsSubjectPrincipal is a boolean indicating whether the call should
+ receive the subject nsIPrincipal as argument.
+
+ needsCallerType is a boolean indicating whether the call should receive
+ a PrincipalType for the caller.
+
+ isFallible is a boolean indicating whether the call should be fallible.
+
+ resultVar: If the returnType is not void, then the result of the call is
+ stored in a C++ variable named by resultVar. The caller is responsible for
+ declaring the result variable. If the caller doesn't care about the result
+ value, resultVar can be omitted.
+ """
+ def __init__(self, isFallible, needsSubjectPrincipal, needsCallerType,
+ arguments, argsPre, returnType, extendedAttributes, descriptor,
+ nativeMethodName, static, object="self", argsPost=[],
+ resultVar=None):
+ CGThing.__init__(self)
+
+ result, resultOutParam, resultRooter, resultArgs, resultConversion = \
+ getRetvalDeclarationForType(returnType, descriptor)
+
+ args = CGList([CGGeneric(arg) for arg in argsPre], ", ")
+ for a, name in arguments:
+ arg = CGGeneric(name)
+
+ # Now constify the things that need it
+ def needsConst(a):
+ if a.type.isDictionary():
+ return True
+ if a.type.isSequence():
+ return True
+ if a.type.isMozMap():
+ return True
+ # isObject() types are always a JS::Rooted, whether
+ # nullable or not, and it turns out a const JS::Rooted
+ # is not very helpful at all (in particular, it won't
+ # even convert to a JS::Handle).
+ # XXX bz Well, why not???
+ if a.type.nullable() and not a.type.isObject():
+ return True
+ if a.type.isString():
+ return True
+ if a.canHaveMissingValue():
+ # This will need an Optional or it's a variadic;
+ # in both cases it should be const.
+ return True
+ if a.type.isUnion():
+ return True
+ if a.type.isSpiderMonkeyInterface():
+ return True
+ return False
+ if needsConst(a):
+ arg = CGWrapper(arg, pre="Constify(", post=")")
+ # And convert NonNull<T> to T&
+ if (((a.type.isGeckoInterface() or a.type.isCallback()) and not a.type.nullable()) or
+ a.type.isDOMString()):
+ arg = CGWrapper(arg, pre="NonNullHelper(", post=")")
+ args.append(arg)
+
+ needResultDecl = False
+
+ # Return values that go in outparams go here
+ if resultOutParam is not None:
+ if resultVar is None:
+ needResultDecl = True
+ resultVar = "result"
+ if resultOutParam == "ref":
+ args.append(CGGeneric(resultVar))
+ else:
+ assert resultOutParam == "ptr"
+ args.append(CGGeneric("&" + resultVar))
+
+ if needsSubjectPrincipal:
+ args.append(CGGeneric("subjectPrincipal"))
+
+ if needsCallerType:
+ args.append(CGGeneric("callerType"))
+
+ if isFallible:
+ args.append(CGGeneric("rv"))
+ args.extend(CGGeneric(arg) for arg in argsPost)
+
+ # Build up our actual call
+ self.cgRoot = CGList([])
+
+ call = CGGeneric(nativeMethodName)
+ if not static:
+ call = CGWrapper(call, pre="%s->" % object)
+ call = CGList([call, CGWrapper(args, pre="(", post=")")])
+ if resultConversion is not None:
+ call = CGList([resultConversion, CGWrapper(call, pre="(", post=")")])
+ if resultVar is None and result is not None:
+ needResultDecl = True
+ resultVar = "result"
+
+ if needResultDecl:
+ if resultRooter is not None:
+ self.cgRoot.prepend(resultRooter)
+ if resultArgs is not None:
+ resultArgsStr = "(%s)" % resultArgs
+ else:
+ resultArgsStr = ""
+ result = CGWrapper(result, post=(" %s%s" % (resultVar, resultArgsStr)))
+ if resultOutParam is None and resultArgs is None:
+ call = CGList([result, CGWrapper(call, pre="(", post=")")])
+ else:
+ self.cgRoot.prepend(CGWrapper(result, post=";\n"))
+ if resultOutParam is None:
+ call = CGWrapper(call, pre=resultVar + " = ")
+ elif result is not None:
+ assert resultOutParam is None
+ call = CGWrapper(call, pre=resultVar + " = ")
+
+ call = CGWrapper(call, post=";\n")
+ self.cgRoot.append(call)
+
+ if needsSubjectPrincipal:
+ getPrincipal = dedent(
+ """
+ JSCompartment* compartment = js::GetContextCompartment(cx);
+ MOZ_ASSERT(compartment);
+ JSPrincipals* principals = JS_GetCompartmentPrincipals(compartment);
+ """)
+
+ if descriptor.interface.isExposedInAnyWorker():
+ self.cgRoot.prepend(CGGeneric(fill(
+ """
+ Maybe<nsIPrincipal*> subjectPrincipal;
+ if (NS_IsMainThread()) {
+ $*{getPrincipal}
+ subjectPrincipal.emplace(nsJSPrincipals::get(principals));
+ }
+ """,
+ getPrincipal=getPrincipal)))
+ else:
+ self.cgRoot.prepend(CGGeneric(fill(
+ """
+ $*{getPrincipal}
+ // Initializing a nonnull is pretty darn annoying...
+ NonNull<nsIPrincipal> subjectPrincipal;
+ subjectPrincipal = static_cast<nsIPrincipal*>(nsJSPrincipals::get(principals));
+ """,
+ getPrincipal=getPrincipal)))
+
+ if needsCallerType:
+ # Note that we do not want to use
+ # IsCallerChrome/ThreadsafeIsCallerChrome directly because those
+ # will pull in the check for UniversalXPConnect, which we ideally
+ # don't want to have in the new thing we're doing here. If not
+ # NS_IsMainThread(), though, we'll go ahead and call
+ # ThreasafeIsCallerChrome(), since that won't mess with
+ # UnivesalXPConnect and we don't want to worry about the right
+ # worker includes here.
+ callerCheck = CGGeneric("callerType = nsContentUtils::IsSystemPrincipal(nsContentUtils::SubjectPrincipal()) ? CallerType::System : CallerType::NonSystem;\n")
+ if descriptor.interface.isExposedInAnyWorker():
+ callerCheck = CGIfElseWrapper(
+ "NS_IsMainThread()",
+ callerCheck,
+ CGGeneric("callerType = nsContentUtils::ThreadsafeIsCallerChrome() ? CallerType::System : CallerType::NonSystem;\n"));
+ self.cgRoot.prepend(callerCheck)
+ self.cgRoot.prepend(CGGeneric("CallerType callerType;\n"))
+
+ if isFallible:
+ self.cgRoot.prepend(CGGeneric("binding_detail::FastErrorResult rv;\n"))
+ self.cgRoot.append(CGGeneric(dedent(
+ """
+ if (MOZ_UNLIKELY(rv.MaybeSetPendingException(cx))) {
+ return false;
+ }
+ """)))
+
+ self.cgRoot.append(CGGeneric("MOZ_ASSERT(!JS_IsExceptionPending(cx));\n"))
+
+ def define(self):
+ return self.cgRoot.define()
+
+
+def getUnionMemberName(type):
+ if type.isGeckoInterface():
+ return type.inner.identifier.name
+ if type.isEnum():
+ return type.inner.identifier.name
+ return type.name
+
+
+class MethodNotNewObjectError(Exception):
+ def __init__(self, typename):
+ self.typename = typename
+
+# A counter for making sure that when we're wrapping up things in
+# nested sequences we don't use the same variable name to iterate over
+# different sequences.
+sequenceWrapLevel = 0
+mapWrapLevel = 0
+
+
+def wrapTypeIntoCurrentCompartment(type, value, isMember=True):
+ """
+ Take the thing named by "value" and if it contains "any",
+ "object", or spidermonkey-interface types inside return a CGThing
+ that will wrap them into the current compartment.
+ """
+ if type.isAny():
+ assert not type.nullable()
+ if isMember:
+ value = "JS::MutableHandle<JS::Value>::fromMarkedLocation(&%s)" % value
+ else:
+ value = "&" + value
+ return CGGeneric("if (!JS_WrapValue(cx, %s)) {\n"
+ " return false;\n"
+ "}\n" % value)
+
+ if type.isObject():
+ if isMember:
+ value = "JS::MutableHandle<JSObject*>::fromMarkedLocation(&%s)" % value
+ else:
+ value = "&" + value
+ return CGGeneric("if (!JS_WrapObject(cx, %s)) {\n"
+ " return false;\n"
+ "}\n" % value)
+
+ if type.isSpiderMonkeyInterface():
+ origValue = value
+ if type.nullable():
+ value = "%s.Value()" % value
+ wrapCode = CGGeneric("if (!%s.WrapIntoNewCompartment(cx)) {\n"
+ " return false;\n"
+ "}\n" % value)
+ if type.nullable():
+ wrapCode = CGIfWrapper(wrapCode, "!%s.IsNull()" % origValue)
+ return wrapCode
+
+ if type.isSequence():
+ origValue = value
+ origType = type
+ if type.nullable():
+ type = type.inner
+ value = "%s.Value()" % value
+ global sequenceWrapLevel
+ index = "indexName%d" % sequenceWrapLevel
+ sequenceWrapLevel += 1
+ wrapElement = wrapTypeIntoCurrentCompartment(type.inner,
+ "%s[%s]" % (value, index))
+ sequenceWrapLevel -= 1
+ if not wrapElement:
+ return None
+ wrapCode = CGWrapper(CGIndenter(wrapElement),
+ pre=("for (uint32_t %s = 0; %s < %s.Length(); ++%s) {\n" %
+ (index, index, value, index)),
+ post="}\n")
+ if origType.nullable():
+ wrapCode = CGIfWrapper(wrapCode, "!%s.IsNull()" % origValue)
+ return wrapCode
+
+ if type.isMozMap():
+ origValue = value
+ origType = type
+ if type.nullable():
+ type = type.inner
+ value = "%s.Value()" % value
+ global mapWrapLevel
+ key = "mapName%d" % mapWrapLevel
+ mapWrapLevel += 1
+ wrapElement = wrapTypeIntoCurrentCompartment(type.inner,
+ "%s.Get(%sKeys[%sIndex])" % (value, key, key))
+ mapWrapLevel -= 1
+ if not wrapElement:
+ return None
+ wrapCode = CGWrapper(CGIndenter(wrapElement),
+ pre=("""
+ nsTArray<nsString> %sKeys;
+ %s.GetKeys(%sKeys);
+ for (uint32_t %sIndex = 0; %sIndex < %sKeys.Length(); ++%sIndex) {
+ """ % (key, value, key, key, key, key, key)),
+ post="}\n")
+ if origType.nullable():
+ wrapCode = CGIfWrapper(wrapCode, "!%s.IsNull()" % origValue)
+ return wrapCode
+
+ if type.isDictionary():
+ assert not type.nullable()
+ myDict = type.inner
+ memberWraps = []
+ while myDict:
+ for member in myDict.members:
+ memberWrap = wrapArgIntoCurrentCompartment(
+ member,
+ "%s.%s" % (value, CGDictionary.makeMemberName(member.identifier.name)))
+ if memberWrap:
+ memberWraps.append(memberWrap)
+ myDict = myDict.parent
+ return CGList(memberWraps) if len(memberWraps) != 0 else None
+
+ if type.isUnion():
+ memberWraps = []
+ if type.nullable():
+ type = type.inner
+ value = "%s.Value()" % value
+ for member in type.flatMemberTypes:
+ memberName = getUnionMemberName(member)
+ memberWrap = wrapTypeIntoCurrentCompartment(
+ member, "%s.GetAs%s()" % (value, memberName))
+ if memberWrap:
+ memberWrap = CGIfWrapper(
+ memberWrap, "%s.Is%s()" % (value, memberName))
+ memberWraps.append(memberWrap)
+ return CGList(memberWraps, "else ") if len(memberWraps) != 0 else None
+
+ if (type.isString() or type.isPrimitive() or type.isEnum() or
+ type.isGeckoInterface() or type.isCallback() or type.isDate()):
+ # All of these don't need wrapping
+ return None
+
+ raise TypeError("Unknown type; we don't know how to wrap it in constructor "
+ "arguments: %s" % type)
+
+
+def wrapArgIntoCurrentCompartment(arg, value, isMember=True):
+ """
+ As wrapTypeIntoCurrentCompartment but handles things being optional
+ """
+ origValue = value
+ isOptional = arg.canHaveMissingValue()
+ if isOptional:
+ value = value + ".Value()"
+ wrap = wrapTypeIntoCurrentCompartment(arg.type, value, isMember)
+ if wrap and isOptional:
+ wrap = CGIfWrapper(wrap, "%s.WasPassed()" % origValue)
+ return wrap
+
+
+def needsContainsHack(m):
+ return m.getExtendedAttribute("ReturnValueNeedsContainsHack")
+
+def needsCallerType(m):
+ return m.getExtendedAttribute("NeedsCallerType")
+
+class CGPerSignatureCall(CGThing):
+ """
+ This class handles the guts of generating code for a particular
+ call signature. A call signature consists of four things:
+
+ 1) A return type, which can be None to indicate that there is no
+ actual return value (e.g. this is an attribute setter) or an
+ IDLType if there's an IDL type involved (including |void|).
+ 2) An argument list, which is allowed to be empty.
+ 3) A name of a native method to call.
+ 4) Whether or not this method is static. Note that this only controls how
+ the method is called (|self->nativeMethodName(...)| vs
+ |nativeMethodName(...)|).
+
+ We also need to know whether this is a method or a getter/setter
+ to do error reporting correctly.
+
+ The idlNode parameter can be either a method or an attr. We can query
+ |idlNode.identifier| in both cases, so we can be agnostic between the two.
+ """
+ # XXXbz For now each entry in the argument list is either an
+ # IDLArgument or a FakeArgument, but longer-term we may want to
+ # have ways of flagging things like JSContext* or optional_argc in
+ # there.
+
+ def __init__(self, returnType, arguments, nativeMethodName, static,
+ descriptor, idlNode, argConversionStartsAt=0, getter=False,
+ setter=False, isConstructor=False, useCounterName=None,
+ resultVar=None):
+ assert idlNode.isMethod() == (not getter and not setter)
+ assert idlNode.isAttr() == (getter or setter)
+ # Constructors are always static
+ assert not isConstructor or static
+
+ CGThing.__init__(self)
+ self.returnType = returnType
+ self.descriptor = descriptor
+ self.idlNode = idlNode
+ self.extendedAttributes = descriptor.getExtendedAttributes(idlNode,
+ getter=getter,
+ setter=setter)
+ self.arguments = arguments
+ self.argCount = len(arguments)
+ self.isConstructor = isConstructor
+ cgThings = []
+
+ # Here, we check if the current getter, setter, method, interface or
+ # inherited interfaces have the UnsafeInPrerendering extended attribute
+ # and if so, we add a check to make sure it is safe.
+ if (idlNode.getExtendedAttribute("UnsafeInPrerendering") or
+ descriptor.interface.getExtendedAttribute("UnsafeInPrerendering") or
+ any(i.getExtendedAttribute("UnsafeInPrerendering")
+ for i in descriptor.interface.getInheritedInterfaces())):
+ cgThings.append(CGGeneric(dedent(
+ """
+ if (!mozilla::dom::EnforceNotInPrerendering(cx, obj)) {
+ // Return false from the JSNative in order to trigger
+ // an uncatchable exception.
+ MOZ_ASSERT(!JS_IsExceptionPending(cx));
+ return false;
+ }
+ """)))
+
+ deprecated = (idlNode.getExtendedAttribute("Deprecated") or
+ (idlNode.isStatic() and descriptor.interface.getExtendedAttribute("Deprecated")))
+ if deprecated:
+ cgThings.append(CGGeneric(dedent(
+ """
+ DeprecationWarning(cx, obj, nsIDocument::e%s);
+ """ % deprecated[0])))
+
+ lenientFloatCode = None
+ if (idlNode.getExtendedAttribute('LenientFloat') is not None and
+ (setter or idlNode.isMethod())):
+ cgThings.append(CGGeneric(dedent(
+ """
+ bool foundNonFiniteFloat = false;
+ """)))
+ lenientFloatCode = "foundNonFiniteFloat = true;\n"
+
+ argsPre = []
+ if idlNode.isStatic():
+ # If we're a constructor, "obj" may not be a function, so calling
+ # XrayAwareCalleeGlobal() on it is not safe. Of course in the
+ # constructor case either "obj" is an Xray or we're already in the
+ # content compartment, not the Xray compartment, so just
+ # constructing the GlobalObject from "obj" is fine.
+ if isConstructor:
+ objForGlobalObject = "obj"
+ else:
+ objForGlobalObject = "xpc::XrayAwareCalleeGlobal(obj)"
+ cgThings.append(CGGeneric(fill(
+ """
+ GlobalObject global(cx, ${obj});
+ if (global.Failed()) {
+ return false;
+ }
+
+ """,
+ obj=objForGlobalObject)))
+ argsPre.append("global")
+
+ # For JS-implemented interfaces we do not want to base the
+ # needsCx decision on the types involved, just on our extended
+ # attributes. Also, JSContext is not needed for the static case
+ # since GlobalObject already contains the context.
+ needsCx = needCx(returnType, arguments, self.extendedAttributes,
+ not descriptor.interface.isJSImplemented(), static)
+ if needsCx:
+ argsPre.append("cx")
+
+ # Hack for making Promise.prototype.then work well over Xrays.
+ if (not idlNode.isStatic() and
+ descriptor.name == "Promise" and
+ idlNode.isMethod() and
+ idlNode.identifier.name == "then"):
+ cgThings.append(CGGeneric(dedent(
+ """
+ JS::Rooted<JSObject*> calleeGlobal(cx, xpc::XrayAwareCalleeGlobal(&args.callee()));
+ """)))
+ argsPre.append("calleeGlobal")
+
+ needsUnwrap = False
+ argsPost = []
+ if isConstructor:
+ if descriptor.name == "Promise":
+ # Hack for Promise for now: pass in our desired proto so the
+ # implementation can create the reflector with the right proto.
+ argsPost.append("desiredProto")
+ # Also, we do not want to enter the content compartment when the
+ # Promise constructor is called via Xrays, because we want to
+ # create our callback functions that we will hand to our caller
+ # in the Xray compartment. The reason we want to do that is the
+ # following situation, over Xrays:
+ #
+ # contentWindow.Promise.race([Promise.resolve(5)])
+ #
+ # Ideally this would work. Internally, race() does a
+ # contentWindow.Promise.resolve() on everything in the array.
+ # Per spec, to support subclassing,
+ # contentWindow.Promise.resolve has to do:
+ #
+ # var resolve, reject;
+ # var p = new contentWindow.Promise(function(a, b) {
+ # resolve = a;
+ # reject = b;
+ # });
+ # resolve(arg);
+ # return p;
+ #
+ # where "arg" is, in this case, the chrome-side return value of
+ # Promise.resolve(5). But if the "resolve" function in that
+ # case were created in the content compartment, then calling it
+ # would wrap "arg" in an opaque wrapper, and that function tries
+ # to get .then off the argument, which would throw. So we need
+ # to create the "resolve" function in the chrome compartment,
+ # and hence want to be running the entire Promise constructor
+ # (which creates that function) in the chrome compartment in
+ # this case. So don't set needsUnwrap here.
+ else:
+ needsUnwrap = True
+ needsUnwrappedVar = False
+ unwrappedVar = "obj"
+ elif descriptor.interface.isJSImplemented():
+ if not idlNode.isStatic():
+ needsUnwrap = True
+ needsUnwrappedVar = True
+ argsPost.append("js::GetObjectCompartment(unwrappedObj ? *unwrappedObj : obj)")
+ elif needScopeObject(returnType, arguments, self.extendedAttributes,
+ descriptor.wrapperCache, True,
+ idlNode.getExtendedAttribute("StoreInSlot")):
+ needsUnwrap = True
+ needsUnwrappedVar = True
+ argsPre.append("unwrappedObj ? *unwrappedObj : obj")
+
+ if idlNode.isStatic() and not isConstructor and descriptor.name == "Promise":
+ # Hack for Promise for now: pass in the "this" value to
+ # Promise static methods.
+ argsPre.append("args.thisv()")
+
+ if needsUnwrap and needsUnwrappedVar:
+ # We cannot assign into obj because it's a Handle, not a
+ # MutableHandle, so we need a separate Rooted.
+ cgThings.append(CGGeneric("Maybe<JS::Rooted<JSObject*> > unwrappedObj;\n"))
+ unwrappedVar = "unwrappedObj.ref()"
+
+ if idlNode.isMethod() and idlNode.isLegacycaller():
+ # If we can have legacycaller with identifier, we can't
+ # just use the idlNode to determine whether we're
+ # generating code for the legacycaller or not.
+ assert idlNode.isIdentifierLess()
+ # Pass in our thisVal
+ argsPre.append("args.thisv()")
+
+ ourName = "%s.%s" % (descriptor.interface.identifier.name,
+ idlNode.identifier.name)
+ if idlNode.isMethod():
+ argDescription = "argument %(index)d of " + ourName
+ elif setter:
+ argDescription = "value being assigned to %s" % ourName
+ else:
+ assert self.argCount == 0
+
+ if needsUnwrap:
+ # It's very important that we construct our unwrappedObj, if we need
+ # to do it, before we might start setting up Rooted things for our
+ # arguments, so that we don't violate the stack discipline Rooted
+ # depends on.
+ cgThings.append(CGGeneric(
+ "bool objIsXray = xpc::WrapperFactory::IsXrayWrapper(obj);\n"))
+ if needsUnwrappedVar:
+ cgThings.append(CGIfWrapper(
+ CGGeneric("unwrappedObj.emplace(cx, obj);\n"),
+ "objIsXray"))
+
+ for i in range(argConversionStartsAt, self.argCount):
+ cgThings.append(
+ CGArgumentConverter(arguments[i], i, self.descriptor,
+ argDescription % {"index": i + 1},
+ idlNode, invalidEnumValueFatal=not setter,
+ lenientFloatCode=lenientFloatCode))
+
+ # Now that argument processing is done, enforce the LenientFloat stuff
+ if lenientFloatCode:
+ if setter:
+ foundNonFiniteFloatBehavior = "return true;\n"
+ else:
+ assert idlNode.isMethod()
+ foundNonFiniteFloatBehavior = dedent(
+ """
+ args.rval().setUndefined();
+ return true;
+ """)
+ cgThings.append(CGGeneric(fill(
+ """
+ if (foundNonFiniteFloat) {
+ $*{returnSteps}
+ }
+ """,
+ returnSteps=foundNonFiniteFloatBehavior)))
+
+ if needsUnwrap:
+ # Something depends on having the unwrapped object, so unwrap it now.
+ xraySteps = []
+ # XXXkhuey we should be able to MOZ_ASSERT that ${obj} is
+ # not null.
+ xraySteps.append(
+ CGGeneric(fill(
+ """
+ ${obj} = js::CheckedUnwrap(${obj});
+ if (!${obj}) {
+ return false;
+ }
+ """,
+ obj=unwrappedVar)))
+ if isConstructor:
+ # If we're called via an xray, we need to enter the underlying
+ # object's compartment and then wrap up all of our arguments into
+ # that compartment as needed. This is all happening after we've
+ # already done the conversions from JS values to WebIDL (C++)
+ # values, so we only need to worry about cases where there are 'any'
+ # or 'object' types, or other things that we represent as actual
+ # JSAPI types, present. Effectively, we're emulating a
+ # CrossCompartmentWrapper, but working with the C++ types, not the
+ # original list of JS::Values.
+ cgThings.append(CGGeneric("Maybe<JSAutoCompartment> ac;\n"))
+ xraySteps.append(CGGeneric("ac.emplace(cx, obj);\n"))
+ xraySteps.append(CGGeneric(dedent(
+ """
+ if (!JS_WrapObject(cx, &desiredProto)) {
+ return false;
+ }
+ """)))
+ xraySteps.extend(
+ wrapArgIntoCurrentCompartment(arg, argname, isMember=False)
+ for arg, argname in self.getArguments())
+
+ cgThings.append(
+ CGIfWrapper(CGList(xraySteps),
+ "objIsXray"))
+
+ # If this is a method that was generated by a maplike/setlike
+ # interface, use the maplike/setlike generator to fill in the body.
+ # Otherwise, use CGCallGenerator to call the native method.
+ if idlNode.isMethod() and idlNode.isMaplikeOrSetlikeOrIterableMethod():
+ if (idlNode.maplikeOrSetlikeOrIterable.isMaplike() or
+ idlNode.maplikeOrSetlikeOrIterable.isSetlike()):
+ cgThings.append(CGMaplikeOrSetlikeMethodGenerator(descriptor,
+ idlNode.maplikeOrSetlikeOrIterable,
+ idlNode.identifier.name))
+ else:
+ cgThings.append(CGIterableMethodGenerator(descriptor,
+ idlNode.maplikeOrSetlikeOrIterable,
+ idlNode.identifier.name))
+ else:
+ cgThings.append(CGCallGenerator(
+ self.isFallible(),
+ idlNode.getExtendedAttribute('NeedsSubjectPrincipal'),
+ needsCallerType(idlNode),
+ self.getArguments(), argsPre, returnType,
+ self.extendedAttributes, descriptor,
+ nativeMethodName,
+ static, argsPost=argsPost, resultVar=resultVar))
+
+ if useCounterName:
+ # Generate a telemetry call for when [UseCounter] is used.
+ code = "SetDocumentAndPageUseCounter(cx, obj, eUseCounter_%s);\n" % useCounterName
+ cgThings.append(CGGeneric(code))
+
+ self.cgRoot = CGList(cgThings)
+
+ def getArguments(self):
+ return [(a, "arg" + str(i)) for i, a in enumerate(self.arguments)]
+
+ def isFallible(self):
+ return 'infallible' not in self.extendedAttributes
+
+ def wrap_return_value(self):
+ wrapCode = ""
+
+ returnsNewObject = memberReturnsNewObject(self.idlNode)
+ if (returnsNewObject and
+ self.returnType.isGeckoInterface()):
+ wrapCode += dedent(
+ """
+ static_assert(!IsPointer<decltype(result)>::value,
+ "NewObject implies that we need to keep the object alive with a strong reference.");
+ """)
+
+ setSlot = self.idlNode.isAttr() and self.idlNode.slotIndices is not None
+ if setSlot:
+ # For attributes in slots, we want to do some
+ # post-processing once we've wrapped them.
+ successCode = "break;\n"
+ else:
+ successCode = None
+
+ resultTemplateValues = {
+ 'jsvalRef': 'args.rval()',
+ 'jsvalHandle': 'args.rval()',
+ 'returnsNewObject': returnsNewObject,
+ 'isConstructorRetval': self.isConstructor,
+ 'successCode': successCode,
+ # 'obj' in this dictionary is the thing whose compartment we are
+ # trying to do the to-JS conversion in. We're going to put that
+ # thing in a variable named "conversionScope" if setSlot is true.
+ # Otherwise, just use "obj" for lack of anything better.
+ 'obj': "conversionScope" if setSlot else "obj"
+ }
+ try:
+ wrapCode += wrapForType(self.returnType, self.descriptor, resultTemplateValues)
+ except MethodNotNewObjectError, err:
+ assert not returnsNewObject
+ raise TypeError("%s being returned from non-NewObject method or property %s.%s" %
+ (err.typename,
+ self.descriptor.interface.identifier.name,
+ self.idlNode.identifier.name))
+ if setSlot:
+ # When using a slot on the Xray expando, we need to make sure that
+ # our initial conversion to a JS::Value is done in the caller
+ # compartment. When using a slot on our reflector, we want to do
+ # the conversion in the compartment of that reflector (that is,
+ # slotStorage). In both cases we want to make sure that we finally
+ # set up args.rval() to be in the caller compartment. We also need
+ # to make sure that the conversion steps happen inside a do/while
+ # that they can break out of on success.
+ #
+ # Of course we always have to wrap the value into the slotStorage
+ # compartment before we store it in slotStorage.
+
+ # postConversionSteps are the steps that run while we're still in
+ # the compartment we do our conversion in but after we've finished
+ # the initial conversion into args.rval().
+ postConversionSteps = ""
+ if needsContainsHack(self.idlNode):
+ # Define a .contains on the object that has the same value as
+ # .includes; needed for backwards compat in extensions as we
+ # migrate some DOMStringLists to FrozenArray.
+ postConversionSteps += dedent(
+ """
+ if (args.rval().isObject() && nsContentUtils::ThreadsafeIsCallerChrome()) {
+ JS::Rooted<JSObject*> rvalObj(cx, &args.rval().toObject());
+ JS::Rooted<JS::Value> includesVal(cx);
+ if (!JS_GetProperty(cx, rvalObj, "includes", &includesVal) ||
+ !JS_DefineProperty(cx, rvalObj, "contains", includesVal, JSPROP_ENUMERATE)) {
+ return false;
+ }
+ }
+
+ """)
+ if self.idlNode.getExtendedAttribute("Frozen"):
+ assert self.idlNode.type.isSequence() or self.idlNode.type.isDictionary()
+ freezeValue = CGGeneric(
+ "JS::Rooted<JSObject*> rvalObj(cx, &args.rval().toObject());\n"
+ "if (!JS_FreezeObject(cx, rvalObj)) {\n"
+ " return false;\n"
+ "}\n")
+ if self.idlNode.type.nullable():
+ freezeValue = CGIfWrapper(freezeValue,
+ "args.rval().isObject()")
+ postConversionSteps += freezeValue.define()
+
+ # slotStorageSteps are steps that run once we have entered the
+ # slotStorage compartment.
+ slotStorageSteps= fill(
+ """
+ // Make a copy so that we don't do unnecessary wrapping on args.rval().
+ JS::Rooted<JS::Value> storedVal(cx, args.rval());
+ if (!${maybeWrap}(cx, &storedVal)) {
+ return false;
+ }
+ js::SetReservedSlot(slotStorage, slotIndex, storedVal);
+ """,
+ maybeWrap=getMaybeWrapValueFuncForType(self.idlNode.type))
+
+ checkForXray = mayUseXrayExpandoSlots(self.descriptor, self.idlNode)
+
+ # For the case of Cached attributes, go ahead and preserve our
+ # wrapper if needed. We need to do this because otherwise the
+ # wrapper could get garbage-collected and the cached value would
+ # suddenly disappear, but the whole premise of cached values is that
+ # they never change without explicit action on someone's part. We
+ # don't do this for StoreInSlot, since those get dealt with during
+ # wrapper setup, and failure would involve us trying to clear an
+ # already-preserved wrapper.
+ if (self.idlNode.getExtendedAttribute("Cached") and
+ self.descriptor.wrapperCache):
+ preserveWrapper = dedent(
+ """
+ PreserveWrapper(self);
+ """)
+ if checkForXray:
+ preserveWrapper = fill(
+ """
+ if (!isXray) {
+ // In the Xray case we don't need to do this, because getting the
+ // expando object already preserved our wrapper.
+ $*{preserveWrapper}
+ }
+ """,
+ preserveWrapper=preserveWrapper)
+ slotStorageSteps += preserveWrapper
+
+ if checkForXray:
+ conversionScope = "isXray ? obj : slotStorage"
+ else:
+ conversionScope = "slotStorage"
+
+ wrapCode = fill(
+ """
+ {
+ JS::Rooted<JSObject*> conversionScope(cx, ${conversionScope});
+ JSAutoCompartment ac(cx, conversionScope);
+ do { // block we break out of when done wrapping
+ $*{wrapCode}
+ } while (0);
+ $*{postConversionSteps}
+ }
+ { // And now store things in the compartment of our slotStorage.
+ JSAutoCompartment ac(cx, slotStorage);
+ $*{slotStorageSteps}
+ }
+ // And now make sure args.rval() is in the caller compartment
+ return ${maybeWrap}(cx, args.rval());
+ """,
+ conversionScope=conversionScope,
+ wrapCode=wrapCode,
+ postConversionSteps=postConversionSteps,
+ slotStorageSteps=slotStorageSteps,
+ maybeWrap=getMaybeWrapValueFuncForType(self.idlNode.type))
+ return wrapCode
+
+ def define(self):
+ return (self.cgRoot.define() + self.wrap_return_value())
+
+
+class CGSwitch(CGList):
+ """
+ A class to generate code for a switch statement.
+
+ Takes three constructor arguments: an expression, a list of cases,
+ and an optional default.
+
+ Each case is a CGCase. The default is a CGThing for the body of
+ the default case, if any.
+ """
+ def __init__(self, expression, cases, default=None):
+ CGList.__init__(self, [CGIndenter(c) for c in cases])
+ self.prepend(CGGeneric("switch (" + expression + ") {\n"))
+ if default is not None:
+ self.append(
+ CGIndenter(
+ CGWrapper(
+ CGIndenter(default),
+ pre="default: {\n",
+ post=" break;\n}\n")))
+
+ self.append(CGGeneric("}\n"))
+
+
+class CGCase(CGList):
+ """
+ A class to generate code for a case statement.
+
+ Takes three constructor arguments: an expression, a CGThing for
+ the body (allowed to be None if there is no body), and an optional
+ argument (defaulting to False) for whether to fall through.
+ """
+ def __init__(self, expression, body, fallThrough=False):
+ CGList.__init__(self, [])
+ self.append(CGGeneric("case " + expression + ": {\n"))
+ bodyList = CGList([body])
+ if fallThrough:
+ bodyList.append(CGGeneric("MOZ_FALLTHROUGH;\n"))
+ else:
+ bodyList.append(CGGeneric("break;\n"))
+ self.append(CGIndenter(bodyList))
+ self.append(CGGeneric("}\n"))
+
+
+class CGMethodCall(CGThing):
+ """
+ A class to generate selection of a method signature from a set of
+ signatures and generation of a call to that signature.
+ """
+ def __init__(self, nativeMethodName, static, descriptor, method,
+ isConstructor=False, constructorName=None):
+ CGThing.__init__(self)
+
+ if isConstructor:
+ assert constructorName is not None
+ methodName = constructorName
+ else:
+ methodName = "%s.%s" % (descriptor.interface.identifier.name, method.identifier.name)
+ argDesc = "argument %d of " + methodName
+
+ if method.getExtendedAttribute("UseCounter"):
+ useCounterName = methodName.replace(".", "_")
+ else:
+ useCounterName = None
+
+ if method.isStatic():
+ nativeType = descriptor.nativeType
+ staticTypeOverride = PropertyDefiner.getStringAttr(method, "StaticClassOverride")
+ if (staticTypeOverride):
+ nativeType = staticTypeOverride
+ nativeMethodName = "%s::%s" % (nativeType, nativeMethodName)
+
+ def requiredArgCount(signature):
+ arguments = signature[1]
+ if len(arguments) == 0:
+ return 0
+ requiredArgs = len(arguments)
+ while requiredArgs and arguments[requiredArgs-1].optional:
+ requiredArgs -= 1
+ return requiredArgs
+
+ def getPerSignatureCall(signature, argConversionStartsAt=0):
+ return CGPerSignatureCall(signature[0], signature[1],
+ nativeMethodName, static, descriptor,
+ method,
+ argConversionStartsAt=argConversionStartsAt,
+ isConstructor=isConstructor,
+ useCounterName=useCounterName)
+
+ signatures = method.signatures()
+ if len(signatures) == 1:
+ # Special case: we can just do a per-signature method call
+ # here for our one signature and not worry about switching
+ # on anything.
+ signature = signatures[0]
+ self.cgRoot = CGList([getPerSignatureCall(signature)])
+ requiredArgs = requiredArgCount(signature)
+
+ # Skip required arguments check for maplike/setlike interfaces, as
+ # they can have arguments which are not passed, and are treated as
+ # if undefined had been explicitly passed.
+ if requiredArgs > 0 and not method.isMaplikeOrSetlikeOrIterableMethod():
+ code = fill(
+ """
+ if (MOZ_UNLIKELY(args.length() < ${requiredArgs})) {
+ return ThrowErrorMessage(cx, MSG_MISSING_ARGUMENTS, "${methodName}");
+ }
+ """,
+ requiredArgs=requiredArgs,
+ methodName=methodName)
+ self.cgRoot.prepend(CGGeneric(code))
+ return
+
+ # Need to find the right overload
+ maxArgCount = method.maxArgCount
+ allowedArgCounts = method.allowedArgCounts
+
+ argCountCases = []
+ for argCountIdx, argCount in enumerate(allowedArgCounts):
+ possibleSignatures = method.signaturesForArgCount(argCount)
+
+ # Try to optimize away cases when the next argCount in the list
+ # will have the same code as us; if it does, we can fall through to
+ # that case.
+ if argCountIdx+1 < len(allowedArgCounts):
+ nextPossibleSignatures = method.signaturesForArgCount(allowedArgCounts[argCountIdx+1])
+ else:
+ nextPossibleSignatures = None
+ if possibleSignatures == nextPossibleSignatures:
+ # Same set of signatures means we better have the same
+ # distinguishing index. So we can in fact just fall through to
+ # the next case here.
+ assert (len(possibleSignatures) == 1 or
+ (method.distinguishingIndexForArgCount(argCount) ==
+ method.distinguishingIndexForArgCount(allowedArgCounts[argCountIdx+1])))
+ argCountCases.append(CGCase(str(argCount), None, True))
+ continue
+
+ if len(possibleSignatures) == 1:
+ # easy case!
+ signature = possibleSignatures[0]
+ argCountCases.append(
+ CGCase(str(argCount), getPerSignatureCall(signature)))
+ continue
+
+ distinguishingIndex = method.distinguishingIndexForArgCount(argCount)
+
+ def distinguishingArgument(signature):
+ args = signature[1]
+ if distinguishingIndex < len(args):
+ return args[distinguishingIndex]
+ assert args[-1].variadic
+ return args[-1]
+
+ def distinguishingType(signature):
+ return distinguishingArgument(signature).type
+
+ for sig in possibleSignatures:
+ # We should not have "any" args at distinguishingIndex,
+ # since we have multiple possible signatures remaining,
+ # but "any" is never distinguishable from anything else.
+ assert not distinguishingType(sig).isAny()
+ # We can't handle unions at the distinguishing index.
+ if distinguishingType(sig).isUnion():
+ raise TypeError("No support for unions as distinguishing "
+ "arguments yet: %s" %
+ distinguishingArgument(sig).location)
+ # We don't support variadics as the distinguishingArgument yet.
+ # If you want to add support, consider this case:
+ #
+ # void(long... foo);
+ # void(long bar, Int32Array baz);
+ #
+ # in which we have to convert argument 0 to long before picking
+ # an overload... but all the variadic stuff needs to go into a
+ # single array in case we pick that overload, so we have to have
+ # machinery for converting argument 0 to long and then either
+ # placing it in the variadic bit or not. Or something. We may
+ # be able to loosen this restriction if the variadic arg is in
+ # fact at distinguishingIndex, perhaps. Would need to
+ # double-check.
+ if distinguishingArgument(sig).variadic:
+ raise TypeError("No support for variadics as distinguishing "
+ "arguments yet: %s" %
+ distinguishingArgument(sig).location)
+
+ # Convert all our arguments up to the distinguishing index.
+ # Doesn't matter which of the possible signatures we use, since
+ # they all have the same types up to that point; just use
+ # possibleSignatures[0]
+ caseBody = [CGArgumentConverter(possibleSignatures[0][1][i],
+ i, descriptor,
+ argDesc % (i + 1), method)
+ for i in range(0, distinguishingIndex)]
+
+ # Select the right overload from our set.
+ distinguishingArg = "args[%d]" % distinguishingIndex
+
+ def tryCall(signature, indent, isDefinitelyObject=False,
+ isNullOrUndefined=False):
+ assert not isDefinitelyObject or not isNullOrUndefined
+ assert isDefinitelyObject or isNullOrUndefined
+ if isDefinitelyObject:
+ failureCode = "break;\n"
+ else:
+ failureCode = None
+ type = distinguishingType(signature)
+ # The argument at index distinguishingIndex can't possibly be
+ # unset here, because we've already checked that argc is large
+ # enough that we can examine this argument. But note that we
+ # still want to claim that optional arguments are optional, in
+ # case undefined was passed in.
+ argIsOptional = distinguishingArgument(signature).canHaveMissingValue()
+ testCode = instantiateJSToNativeConversion(
+ getJSToNativeConversionInfo(type, descriptor,
+ failureCode=failureCode,
+ isDefinitelyObject=isDefinitelyObject,
+ isNullOrUndefined=isNullOrUndefined,
+ isOptional=argIsOptional,
+ sourceDescription=(argDesc % (distinguishingIndex + 1))),
+ {
+ "declName": "arg%d" % distinguishingIndex,
+ "holderName": ("arg%d" % distinguishingIndex) + "_holder",
+ "val": distinguishingArg,
+ "obj": "obj",
+ "haveValue": "args.hasDefined(%d)" % distinguishingIndex,
+ "passedToJSImpl": toStringBool(isJSImplementedDescriptor(descriptor))
+ },
+ checkForValue=argIsOptional)
+ caseBody.append(CGIndenter(testCode, indent))
+
+ # If we got this far, we know we unwrapped to the right
+ # C++ type, so just do the call. Start conversion with
+ # distinguishingIndex + 1, since we already converted
+ # distinguishingIndex.
+ caseBody.append(CGIndenter(
+ getPerSignatureCall(signature, distinguishingIndex + 1),
+ indent))
+
+ def hasConditionalConversion(type):
+ """
+ Return whether the argument conversion for this type will be
+ conditional on the type of incoming JS value. For example, for
+ interface types the conversion is conditional on the incoming
+ value being isObject().
+
+ For the types for which this returns false, we do not have to
+ output extra isUndefined() or isNullOrUndefined() cases, because
+ null/undefined values will just fall through into our
+ unconditional conversion.
+ """
+ if type.isString() or type.isEnum():
+ return False
+ if type.isBoolean():
+ distinguishingTypes = (distinguishingType(s) for s in
+ possibleSignatures)
+ return any(t.isString() or t.isEnum() or t.isNumeric()
+ for t in distinguishingTypes)
+ if type.isNumeric():
+ distinguishingTypes = (distinguishingType(s) for s in
+ possibleSignatures)
+ return any(t.isString() or t.isEnum()
+ for t in distinguishingTypes)
+ return True
+
+ def needsNullOrUndefinedCase(type):
+ """
+ Return true if the type needs a special isNullOrUndefined() case
+ """
+ return ((type.nullable() and
+ hasConditionalConversion(type)) or
+ type.isDictionary())
+
+ # First check for undefined and optional distinguishing arguments
+ # and output a special branch for that case. Note that we don't
+ # use distinguishingArgument here because we actualy want to
+ # exclude variadic arguments. Also note that we skip this check if
+ # we plan to output a isNullOrUndefined() special case for this
+ # argument anyway, since that will subsume our isUndefined() check.
+ # This is safe, because there can be at most one nullable
+ # distinguishing argument, so if we're it we'll definitely get
+ # picked up by the nullable handling. Also, we can skip this check
+ # if the argument has an unconditional conversion later on.
+ undefSigs = [s for s in possibleSignatures if
+ distinguishingIndex < len(s[1]) and
+ s[1][distinguishingIndex].optional and
+ hasConditionalConversion(s[1][distinguishingIndex].type) and
+ not needsNullOrUndefinedCase(s[1][distinguishingIndex].type)]
+ # Can't have multiple signatures with an optional argument at the
+ # same index.
+ assert len(undefSigs) < 2
+ if len(undefSigs) > 0:
+ caseBody.append(CGGeneric("if (%s.isUndefined()) {\n" %
+ distinguishingArg))
+ tryCall(undefSigs[0], 2, isNullOrUndefined=True)
+ caseBody.append(CGGeneric("}\n"))
+
+ # Next, check for null or undefined. That means looking for
+ # nullable arguments at the distinguishing index and outputting a
+ # separate branch for them. But if the nullable argument has an
+ # unconditional conversion, we don't need to do that. The reason
+ # for that is that at most one argument at the distinguishing index
+ # is nullable (since two nullable arguments are not
+ # distinguishable), and null/undefined values will always fall
+ # through to the unconditional conversion we have, if any, since
+ # they will fail whatever the conditions on the input value are for
+ # our other conversions.
+ nullOrUndefSigs = [s for s in possibleSignatures
+ if needsNullOrUndefinedCase(distinguishingType(s))]
+ # Can't have multiple nullable types here
+ assert len(nullOrUndefSigs) < 2
+ if len(nullOrUndefSigs) > 0:
+ caseBody.append(CGGeneric("if (%s.isNullOrUndefined()) {\n" %
+ distinguishingArg))
+ tryCall(nullOrUndefSigs[0], 2, isNullOrUndefined=True)
+ caseBody.append(CGGeneric("}\n"))
+
+ # Now check for distinguishingArg being various kinds of objects.
+ # The spec says to check for the following things in order:
+ # 1) A platform object that's not a platform array object, being
+ # passed to an interface or "object" arg.
+ # 2) A Date object being passed to a Date or "object" arg.
+ # 3) A RegExp object being passed to a RegExp or "object" arg.
+ # 4) A callable object being passed to a callback or "object" arg.
+ # 5) An iterable object being passed to a sequence arg.
+ # 6) Any non-Date and non-RegExp object being passed to a
+ # array or callback interface or dictionary or
+ # "object" arg.
+
+ # First grab all the overloads that have a non-callback interface
+ # (which includes typed arrays and arraybuffers) at the
+ # distinguishing index. We can also include the ones that have an
+ # "object" here, since if those are present no other object-typed
+ # argument will be.
+ objectSigs = [
+ s for s in possibleSignatures
+ if (distinguishingType(s).isObject() or
+ distinguishingType(s).isNonCallbackInterface())]
+
+ # And all the overloads that take Date
+ objectSigs.extend(s for s in possibleSignatures
+ if distinguishingType(s).isDate())
+
+ # And all the overloads that take callbacks
+ objectSigs.extend(s for s in possibleSignatures
+ if distinguishingType(s).isCallback())
+
+ # And all the overloads that take sequences
+ objectSigs.extend(s for s in possibleSignatures
+ if distinguishingType(s).isSequence())
+
+ # Now append all the overloads that take a dictionary or callback
+ # interface or MozMap. There should be only one of these!
+ genericObjectSigs = [
+ s for s in possibleSignatures
+ if (distinguishingType(s).isDictionary() or
+ distinguishingType(s).isMozMap() or
+ distinguishingType(s).isCallbackInterface())]
+ assert len(genericObjectSigs) <= 1
+ objectSigs.extend(genericObjectSigs)
+
+ # There might be more than one thing in objectSigs; we need to check
+ # which ones we unwrap to.
+ if len(objectSigs) > 0:
+ # Here it's enough to guard on our argument being an object. The
+ # code for unwrapping non-callback interfaces, typed arrays,
+ # sequences, and Dates will just bail out and move on to
+ # the next overload if the object fails to unwrap correctly,
+ # while "object" accepts any object anyway. We could even not
+ # do the isObject() check up front here, but in cases where we
+ # have multiple object overloads it makes sense to do it only
+ # once instead of for each overload. That will also allow the
+ # unwrapping test to skip having to do codegen for the
+ # null-or-undefined case, which we already handled above.
+ caseBody.append(CGGeneric("if (%s.isObject()) {\n" %
+ distinguishingArg))
+ for sig in objectSigs:
+ caseBody.append(CGIndenter(CGGeneric("do {\n")))
+ # Indent by 4, since we need to indent further
+ # than our "do" statement
+ tryCall(sig, 4, isDefinitelyObject=True)
+ caseBody.append(CGIndenter(CGGeneric("} while (0);\n")))
+
+ caseBody.append(CGGeneric("}\n"))
+
+ # Now we only have to consider booleans, numerics, and strings. If
+ # we only have one of them, then we can just output it. But if not,
+ # then we need to output some of the cases conditionally: if we have
+ # a string overload, then boolean and numeric are conditional, and
+ # if not then boolean is conditional if we have a numeric overload.
+ def findUniqueSignature(filterLambda):
+ sigs = filter(filterLambda, possibleSignatures)
+ assert len(sigs) < 2
+ if len(sigs) > 0:
+ return sigs[0]
+ return None
+
+ stringSignature = findUniqueSignature(
+ lambda s: (distinguishingType(s).isString() or
+ distinguishingType(s).isEnum()))
+ numericSignature = findUniqueSignature(
+ lambda s: distinguishingType(s).isNumeric())
+ booleanSignature = findUniqueSignature(
+ lambda s: distinguishingType(s).isBoolean())
+
+ if stringSignature or numericSignature:
+ booleanCondition = "%s.isBoolean()"
+ else:
+ booleanCondition = None
+
+ if stringSignature:
+ numericCondition = "%s.isNumber()"
+ else:
+ numericCondition = None
+
+ def addCase(sig, condition):
+ sigCode = getPerSignatureCall(sig, distinguishingIndex)
+ if condition:
+ sigCode = CGIfWrapper(sigCode,
+ condition % distinguishingArg)
+ caseBody.append(sigCode)
+
+ if booleanSignature:
+ addCase(booleanSignature, booleanCondition)
+ if numericSignature:
+ addCase(numericSignature, numericCondition)
+ if stringSignature:
+ addCase(stringSignature, None)
+
+ if (not booleanSignature and not numericSignature and
+ not stringSignature):
+ # Just throw; we have no idea what we're supposed to
+ # do with this.
+ caseBody.append(CGGeneric(
+ 'return ThrowErrorMessage(cx, MSG_OVERLOAD_RESOLUTION_FAILED, "%d", "%d", "%s");\n' %
+ (distinguishingIndex + 1, argCount, methodName)))
+
+ argCountCases.append(CGCase(str(argCount), CGList(caseBody)))
+
+ overloadCGThings = []
+ overloadCGThings.append(
+ CGGeneric("unsigned argcount = std::min(args.length(), %du);\n" %
+ maxArgCount))
+ overloadCGThings.append(
+ CGSwitch("argcount",
+ argCountCases,
+ CGGeneric('return ThrowErrorMessage(cx, MSG_MISSING_ARGUMENTS, "%s");\n' %
+ methodName)))
+ overloadCGThings.append(
+ CGGeneric('MOZ_CRASH("We have an always-returning default case");\n'
+ 'return false;\n'))
+ self.cgRoot = CGList(overloadCGThings)
+
+ def define(self):
+ return self.cgRoot.define()
+
+
+class CGGetterCall(CGPerSignatureCall):
+ """
+ A class to generate a native object getter call for a particular IDL
+ getter.
+ """
+ def __init__(self, returnType, nativeMethodName, descriptor, attr):
+ if attr.getExtendedAttribute("UseCounter"):
+ useCounterName = "%s_%s_getter" % (descriptor.interface.identifier.name,
+ attr.identifier.name)
+ else:
+ useCounterName = None
+ if attr.isStatic():
+ nativeMethodName = "%s::%s" % (descriptor.nativeType, nativeMethodName)
+ CGPerSignatureCall.__init__(self, returnType, [], nativeMethodName,
+ attr.isStatic(), descriptor, attr,
+ getter=True, useCounterName=useCounterName)
+
+
+class CGNavigatorGetterCall(CGPerSignatureCall):
+ """
+ A class to generate a native object getter call for an IDL getter for a
+ property generated by NavigatorProperty.
+ """
+ def __init__(self, returnType, _, descriptor, attr):
+ nativeMethodName = "%s::ConstructNavigatorObject" % (toBindingNamespace(returnType.inner.identifier.name))
+ CGPerSignatureCall.__init__(self, returnType, [], nativeMethodName,
+ True, descriptor, attr, getter=True)
+
+ def getArguments(self):
+ # The navigator object should be associated with the global of
+ # the navigator it's coming from, which will be the global of
+ # the object whose slot it gets cached in. That's stored in
+ # "slotStorage".
+ return [(FakeArgument(BuiltinTypes[IDLBuiltinType.Types.object],
+ self.idlNode),
+ "slotStorage")]
+
+
+class FakeIdentifier():
+ def __init__(self, name):
+ self.name = name
+
+
+class FakeArgument():
+ """
+ A class that quacks like an IDLArgument. This is used to make
+ setters look like method calls or for special operations.
+ """
+ def __init__(self, type, interfaceMember, name="arg", allowTreatNonCallableAsNull=False):
+ self.type = type
+ self.optional = False
+ self.variadic = False
+ self.defaultValue = None
+ self._allowTreatNonCallableAsNull = allowTreatNonCallableAsNull
+ # For FakeArguments generated by maplike/setlike convenience functions,
+ # we won't have an interfaceMember to pass in.
+ if interfaceMember:
+ self.treatNullAs = interfaceMember.treatNullAs
+ else:
+ self.treatNullAs = "Default"
+ if isinstance(interfaceMember, IDLAttribute):
+ self.enforceRange = interfaceMember.enforceRange
+ self.clamp = interfaceMember.clamp
+ else:
+ self.enforceRange = False
+ self.clamp = False
+
+ self.identifier = FakeIdentifier(name)
+
+ def allowTreatNonCallableAsNull(self):
+ return self._allowTreatNonCallableAsNull
+
+ def canHaveMissingValue(self):
+ return False
+
+
+class CGSetterCall(CGPerSignatureCall):
+ """
+ A class to generate a native object setter call for a particular IDL
+ setter.
+ """
+ def __init__(self, argType, nativeMethodName, descriptor, attr):
+ if attr.getExtendedAttribute("UseCounter"):
+ useCounterName = "%s_%s_setter" % (descriptor.interface.identifier.name,
+ attr.identifier.name)
+ else:
+ useCounterName = None
+ if attr.isStatic():
+ nativeMethodName = "%s::%s" % (descriptor.nativeType, nativeMethodName)
+ CGPerSignatureCall.__init__(self, None,
+ [FakeArgument(argType, attr, allowTreatNonCallableAsNull=True)],
+ nativeMethodName, attr.isStatic(),
+ descriptor, attr, setter=True, useCounterName=useCounterName)
+
+ def wrap_return_value(self):
+ attr = self.idlNode
+ if self.descriptor.wrapperCache and attr.slotIndices is not None:
+ if attr.getExtendedAttribute("StoreInSlot"):
+ args = "cx, self"
+ else:
+ args = "self"
+ clearSlot = ("%s(%s);\n" %
+ (MakeClearCachedValueNativeName(self.idlNode), args))
+ else:
+ clearSlot = ""
+
+ # We have no return value
+ return ("\n"
+ "%s"
+ "return true;\n" % clearSlot)
+
+
+class CGAbstractBindingMethod(CGAbstractStaticMethod):
+ """
+ Common class to generate the JSNatives for all our methods, getters, and
+ setters. This will generate the function declaration and unwrap the
+ |this| object. Subclasses are expected to override the generate_code
+ function to do the rest of the work. This function should return a
+ CGThing which is already properly indented.
+
+ getThisObj should be code for getting a JSObject* for the binding
+ object. If this is None, we will auto-generate code based on
+ descriptor to do the right thing. "" can be passed in if the
+ binding object is already stored in 'obj'.
+
+ callArgs should be code for getting a JS::CallArgs into a variable
+ called 'args'. This can be "" if there is already such a variable
+ around.
+
+ If allowCrossOriginThis is true, then this-unwrapping will first do an
+ UncheckedUnwrap and after that operate on the result.
+ """
+ def __init__(self, descriptor, name, args, unwrapFailureCode=None,
+ getThisObj=None,
+ callArgs="JS::CallArgs args = JS::CallArgsFromVp(argc, vp);\n",
+ allowCrossOriginThis=False):
+ CGAbstractStaticMethod.__init__(self, descriptor, name, "bool", args)
+
+ if unwrapFailureCode is None:
+ self.unwrapFailureCode = 'return ThrowErrorMessage(cx, MSG_THIS_DOES_NOT_IMPLEMENT_INTERFACE, "Value", "%s");\n' % descriptor.interface.identifier.name
+ else:
+ self.unwrapFailureCode = unwrapFailureCode
+
+ if getThisObj == "":
+ self.getThisObj = None
+ else:
+ if getThisObj is None:
+ if descriptor.interface.isOnGlobalProtoChain():
+ ensureCondition = "!args.thisv().isNullOrUndefined() && !args.thisv().isObject()"
+ getThisObj = "args.thisv().isObject() ? &args.thisv().toObject() : js::GetGlobalForObjectCrossCompartment(&args.callee())"
+ else:
+ ensureCondition = "!args.thisv().isObject()"
+ getThisObj = "&args.thisv().toObject()"
+ unwrapFailureCode = self.unwrapFailureCode % {'securityError': 'false'}
+ ensureThisObj = CGIfWrapper(CGGeneric(unwrapFailureCode),
+ ensureCondition)
+ else:
+ ensureThisObj = None
+ self.getThisObj = CGList(
+ [ensureThisObj,
+ CGGeneric("JS::Rooted<JSObject*> obj(cx, %s);\n" %
+ getThisObj)])
+ self.callArgs = callArgs
+ self.allowCrossOriginThis = allowCrossOriginThis
+
+ def definition_body(self):
+ body = self.callArgs
+ if self.getThisObj is not None:
+ body += self.getThisObj.define() + "\n"
+ body += "%s* self;\n" % self.descriptor.nativeType
+ body += dedent(
+ """
+ JS::Rooted<JS::Value> rootSelf(cx, JS::ObjectValue(*obj));
+ """)
+
+ # Our descriptor might claim that we're not castable, simply because
+ # we're someone's consequential interface. But for this-unwrapping, we
+ # know that we're the real deal. So fake a descriptor here for
+ # consumption by CastableObjectUnwrapper.
+ body += str(CastableObjectUnwrapper(
+ self.descriptor,
+ "rootSelf",
+ "&rootSelf",
+ "self",
+ self.unwrapFailureCode,
+ allowCrossOriginObj=self.allowCrossOriginThis))
+
+ return body + self.generate_code().define()
+
+ def generate_code(self):
+ assert False # Override me
+
+
+class CGAbstractStaticBindingMethod(CGAbstractStaticMethod):
+ """
+ Common class to generate the JSNatives for all our static methods, getters
+ and setters. This will generate the function declaration and unwrap the
+ global object. Subclasses are expected to override the generate_code
+ function to do the rest of the work. This function should return a
+ CGThing which is already properly indented.
+ """
+ def __init__(self, descriptor, name):
+ CGAbstractStaticMethod.__init__(self, descriptor, name, "bool",
+ JSNativeArguments())
+
+ def definition_body(self):
+ # Make sure that "obj" is in the same compartment as "cx", since we'll
+ # later use it to wrap return values.
+ unwrap = dedent("""
+ JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
+ JS::Rooted<JSObject*> obj(cx, &args.callee());
+
+ """)
+ return unwrap + self.generate_code().define()
+
+ def generate_code(self):
+ assert False # Override me
+
+
+def MakeNativeName(name):
+ return name[0].upper() + IDLToCIdentifier(name[1:])
+
+
+class CGGenericMethod(CGAbstractBindingMethod):
+ """
+ A class for generating the C++ code for an IDL method.
+
+ If allowCrossOriginThis is true, then this-unwrapping will first do an
+ UncheckedUnwrap and after that operate on the result.
+ """
+ def __init__(self, descriptor, allowCrossOriginThis=False):
+ unwrapFailureCode = (
+ 'return ThrowInvalidThis(cx, args, %%(securityError)s, "%s");\n' %
+ descriptor.interface.identifier.name)
+ name = "genericCrossOriginMethod" if allowCrossOriginThis else "genericMethod"
+ CGAbstractBindingMethod.__init__(self, descriptor, name,
+ JSNativeArguments(),
+ unwrapFailureCode=unwrapFailureCode,
+ allowCrossOriginThis=allowCrossOriginThis)
+
+ def generate_code(self):
+ return CGGeneric(dedent("""
+ const JSJitInfo *info = FUNCTION_VALUE_TO_JITINFO(args.calleev());
+ MOZ_ASSERT(info->type() == JSJitInfo::Method);
+ JSJitMethodOp method = info->method;
+ bool ok = method(cx, obj, self, JSJitMethodCallArgs(args));
+ #ifdef DEBUG
+ if (ok) {
+ AssertReturnTypeMatchesJitinfo(info, args.rval());
+ }
+ #endif
+ return ok;
+ """))
+
+
+class CGGenericPromiseReturningMethod(CGAbstractBindingMethod):
+ """
+ A class for generating the C++ code for an IDL method that returns a Promise.
+
+ Does not handle cross-origin this.
+ """
+ def __init__(self, descriptor):
+ unwrapFailureCode = dedent("""
+ ThrowInvalidThis(cx, args, %%(securityError)s, "%s");\n
+ return ConvertExceptionToPromise(cx, xpc::XrayAwareCalleeGlobal(callee),
+ args.rval());\n""" %
+ descriptor.interface.identifier.name)
+
+ name = "genericPromiseReturningMethod"
+ customCallArgs = dedent("""
+ JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
+ // Make sure to save the callee before someone maybe messes with rval().
+ JS::Rooted<JSObject*> callee(cx, &args.callee());
+ """)
+
+ CGAbstractBindingMethod.__init__(self, descriptor, name,
+ JSNativeArguments(),
+ callArgs=customCallArgs,
+ unwrapFailureCode=unwrapFailureCode)
+
+ def generate_code(self):
+ return CGGeneric(dedent("""
+ const JSJitInfo *info = FUNCTION_VALUE_TO_JITINFO(args.calleev());
+ MOZ_ASSERT(info->type() == JSJitInfo::Method);
+ JSJitMethodOp method = info->method;
+ bool ok = method(cx, obj, self, JSJitMethodCallArgs(args));
+ if (ok) {
+ #ifdef DEBUG
+ AssertReturnTypeMatchesJitinfo(info, args.rval());
+ #endif
+ return true;
+ }
+
+ MOZ_ASSERT(info->returnType() == JSVAL_TYPE_OBJECT);
+ return ConvertExceptionToPromise(cx, xpc::XrayAwareCalleeGlobal(callee),
+ args.rval());
+ """))
+
+
+class CGSpecializedMethod(CGAbstractStaticMethod):
+ """
+ A class for generating the C++ code for a specialized method that the JIT
+ can call with lower overhead.
+ """
+ def __init__(self, descriptor, method):
+ self.method = method
+ name = CppKeywords.checkMethodName(IDLToCIdentifier(method.identifier.name))
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'obj'),
+ Argument('%s*' % descriptor.nativeType, 'self'),
+ Argument('const JSJitMethodCallArgs&', 'args')]
+ CGAbstractStaticMethod.__init__(self, descriptor, name, 'bool', args)
+
+ def definition_body(self):
+ nativeName = CGSpecializedMethod.makeNativeName(self.descriptor,
+ self.method)
+ return CGMethodCall(nativeName, self.method.isStatic(), self.descriptor,
+ self.method).define()
+
+ @staticmethod
+ def makeNativeName(descriptor, method):
+ name = method.identifier.name
+ return MakeNativeName(descriptor.binaryNameFor(name))
+
+
+class CGMethodPromiseWrapper(CGAbstractStaticMethod):
+ """
+ A class for generating a wrapper around another method that will
+ convert exceptions to promises.
+ """
+ def __init__(self, descriptor, methodToWrap):
+ self.method = methodToWrap
+ name = self.makeName(methodToWrap.name)
+ args = list(methodToWrap.args)
+ CGAbstractStaticMethod.__init__(self, descriptor, name, 'bool', args)
+
+ def definition_body(self):
+ return fill(
+ """
+ // Make sure to save the callee before someone maybe messes
+ // with rval().
+ JS::Rooted<JSObject*> callee(cx, &args.callee());
+ bool ok = ${methodName}(${args});
+ if (ok) {
+ return true;
+ }
+ return ConvertExceptionToPromise(cx, xpc::XrayAwareCalleeGlobal(callee),
+ args.rval());
+ """,
+ methodName=self.method.name,
+ args=", ".join(arg.name for arg in self.args))
+
+ @staticmethod
+ def makeName(methodName):
+ return methodName + "_promiseWrapper"
+
+
+class CGJsonifierMethod(CGSpecializedMethod):
+ def __init__(self, descriptor, method):
+ assert method.isJsonifier()
+ CGSpecializedMethod.__init__(self, descriptor, method)
+
+ def definition_body(self):
+ ret = dedent("""
+ JS::Rooted<JSObject*> result(cx, JS_NewPlainObject(cx));
+ if (!result) {
+ return false;
+ }
+ """)
+
+ jsonDescriptors = [self.descriptor]
+ interface = self.descriptor.interface.parent
+ while interface:
+ descriptor = self.descriptor.getDescriptor(interface.identifier.name)
+ if descriptor.operations['Jsonifier']:
+ jsonDescriptors.append(descriptor)
+ interface = interface.parent
+
+ # Iterate the array in reverse: oldest ancestor first
+ for descriptor in jsonDescriptors[::-1]:
+ ret += fill(
+ """
+ if (!${parentclass}::JsonifyAttributes(cx, obj, self, result)) {
+ return false;
+ }
+ """,
+ parentclass=toBindingNamespace(descriptor.name)
+ )
+ ret += ('args.rval().setObject(*result);\n'
+ 'return true;\n')
+ return ret
+
+
+class CGLegacyCallHook(CGAbstractBindingMethod):
+ """
+ Call hook for our object
+ """
+ def __init__(self, descriptor):
+ self._legacycaller = descriptor.operations["LegacyCaller"]
+ # Our "self" is actually the callee in this case, not the thisval.
+ CGAbstractBindingMethod.__init__(
+ self, descriptor, LEGACYCALLER_HOOK_NAME,
+ JSNativeArguments(), getThisObj="&args.callee()")
+
+ def define(self):
+ if not self._legacycaller:
+ return ""
+ return CGAbstractBindingMethod.define(self)
+
+ def generate_code(self):
+ name = self._legacycaller.identifier.name
+ nativeName = MakeNativeName(self.descriptor.binaryNameFor(name))
+ return CGMethodCall(nativeName, False, self.descriptor,
+ self._legacycaller)
+
+
+class CGResolveHook(CGAbstractClassHook):
+ """
+ Resolve hook for objects that have the NeedResolve extended attribute.
+ """
+ def __init__(self, descriptor):
+ assert descriptor.interface.getExtendedAttribute("NeedResolve")
+
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'obj'),
+ Argument('JS::Handle<jsid>', 'id'),
+ Argument('bool*', 'resolvedp')]
+ CGAbstractClassHook.__init__(self, descriptor, RESOLVE_HOOK_NAME,
+ "bool", args)
+
+ def generate_code(self):
+ return dedent("""
+ JS::Rooted<JS::PropertyDescriptor> desc(cx);
+ if (!self->DoResolve(cx, obj, id, &desc)) {
+ return false;
+ }
+ if (!desc.object()) {
+ return true;
+ }
+ // If desc.value() is undefined, then the DoResolve call
+ // has already defined it on the object. Don't try to also
+ // define it.
+ if (!desc.value().isUndefined()) {
+ desc.attributesRef() |= JSPROP_RESOLVING;
+ if (!JS_DefinePropertyById(cx, obj, id, desc)) {
+ return false;
+ }
+ }
+ *resolvedp = true;
+ return true;
+ """)
+
+ def definition_body(self):
+ if self.descriptor.isGlobal():
+ # Resolve standard classes
+ prefix = dedent("""
+ if (!ResolveGlobal(cx, obj, id, resolvedp)) {
+ return false;
+ }
+ if (*resolvedp) {
+ return true;
+ }
+
+ """)
+ else:
+ prefix = ""
+ return prefix + CGAbstractClassHook.definition_body(self)
+
+
+class CGMayResolveHook(CGAbstractStaticMethod):
+ """
+ Resolve hook for objects that have the NeedResolve extended attribute.
+ """
+ def __init__(self, descriptor):
+ assert descriptor.interface.getExtendedAttribute("NeedResolve")
+
+ args = [Argument('const JSAtomState&', 'names'),
+ Argument('jsid', 'id'),
+ Argument('JSObject*', 'maybeObj')]
+ CGAbstractStaticMethod.__init__(self, descriptor, MAY_RESOLVE_HOOK_NAME,
+ "bool", args)
+
+ def definition_body(self):
+ if self.descriptor.isGlobal():
+ # Check whether this would resolve as a standard class.
+ prefix = dedent("""
+ if (MayResolveGlobal(names, id, maybeObj)) {
+ return true;
+ }
+
+ """)
+ else:
+ prefix = ""
+ return (prefix +
+ "return %s::MayResolve(id);\n" % self.descriptor.nativeType)
+
+
+class CGEnumerateHook(CGAbstractBindingMethod):
+ """
+ Enumerate hook for objects with custom hooks.
+ """
+ def __init__(self, descriptor):
+ assert descriptor.interface.getExtendedAttribute("NeedResolve")
+
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'obj')]
+ # Our "self" is actually the "obj" argument in this case, not the thisval.
+ CGAbstractBindingMethod.__init__(
+ self, descriptor, ENUMERATE_HOOK_NAME,
+ args, getThisObj="", callArgs="")
+
+ def generate_code(self):
+ return CGGeneric(dedent("""
+ AutoTArray<nsString, 8> names;
+ binding_detail::FastErrorResult rv;
+ self->GetOwnPropertyNames(cx, names, rv);
+ if (rv.MaybeSetPendingException(cx)) {
+ return false;
+ }
+ bool dummy;
+ for (uint32_t i = 0; i < names.Length(); ++i) {
+ if (!JS_HasUCProperty(cx, obj, names[i].get(), names[i].Length(), &dummy)) {
+ return false;
+ }
+ }
+ return true;
+ """))
+
+ def definition_body(self):
+ if self.descriptor.isGlobal():
+ # Enumerate standard classes
+ prefix = dedent("""
+ if (!EnumerateGlobal(cx, obj)) {
+ return false;
+ }
+
+ """)
+ else:
+ prefix = ""
+ return prefix + CGAbstractBindingMethod.definition_body(self)
+
+
+class CppKeywords():
+ """
+ A class for checking if method names declared in webidl
+ are not in conflict with C++ keywords.
+ """
+ keywords = frozenset([
+ 'alignas', 'alignof', 'and', 'and_eq', 'asm', 'assert', 'auto', 'bitand', 'bitor', 'bool',
+ 'break', 'case', 'catch', 'char', 'char16_t', 'char32_t', 'class', 'compl', 'const',
+ 'constexpr', 'const_cast', 'continue', 'decltype', 'default', 'delete', 'do', 'double',
+ 'dynamic_cast', 'else', 'enum', 'explicit', 'export', 'extern', 'false', 'final', 'float',
+ 'for', 'friend', 'goto', 'if', 'inline', 'int', 'long', 'mutable', 'namespace', 'new',
+ 'noexcept', 'not', 'not_eq', 'nullptr', 'operator', 'or', 'or_eq', 'override', 'private',
+ 'protected', 'public', 'register', 'reinterpret_cast', 'return', 'short', 'signed',
+ 'sizeof', 'static', 'static_assert', 'static_cast', 'struct', 'switch', 'template', 'this',
+ 'thread_local', 'throw', 'true', 'try', 'typedef', 'typeid', 'typename', 'union',
+ 'unsigned', 'using', 'virtual', 'void', 'volatile', 'wchar_t', 'while', 'xor', 'xor_eq'])
+
+ @staticmethod
+ def checkMethodName(name):
+ # Double '_' because 'assert' and '_assert' cannot be used in MS2013 compiler.
+ # Bug 964892 and bug 963560.
+ if name in CppKeywords.keywords:
+ name = '_' + name + '_'
+ return name
+
+
+class CGStaticMethod(CGAbstractStaticBindingMethod):
+ """
+ A class for generating the C++ code for an IDL static method.
+ """
+ def __init__(self, descriptor, method):
+ self.method = method
+ name = CppKeywords.checkMethodName(IDLToCIdentifier(method.identifier.name))
+ CGAbstractStaticBindingMethod.__init__(self, descriptor, name)
+
+ def generate_code(self):
+ nativeName = CGSpecializedMethod.makeNativeName(self.descriptor,
+ self.method)
+ return CGMethodCall(nativeName, True, self.descriptor, self.method)
+
+
+class CGGenericGetter(CGAbstractBindingMethod):
+ """
+ A class for generating the C++ code for an IDL attribute getter.
+ """
+ def __init__(self, descriptor, lenientThis=False, allowCrossOriginThis=False):
+ if lenientThis:
+ name = "genericLenientGetter"
+ unwrapFailureCode = dedent("""
+ MOZ_ASSERT(!JS_IsExceptionPending(cx));
+ if (!ReportLenientThisUnwrappingFailure(cx, &args.callee())) {
+ return false;
+ }
+ args.rval().set(JS::UndefinedValue());
+ return true;
+ """)
+ else:
+ if allowCrossOriginThis:
+ name = "genericCrossOriginGetter"
+ else:
+ name = "genericGetter"
+ unwrapFailureCode = (
+ 'return ThrowInvalidThis(cx, args, %%(securityError)s, "%s");\n' %
+ descriptor.interface.identifier.name)
+ CGAbstractBindingMethod.__init__(self, descriptor, name, JSNativeArguments(),
+ unwrapFailureCode,
+ allowCrossOriginThis=allowCrossOriginThis)
+
+ def generate_code(self):
+ return CGGeneric(dedent("""
+ const JSJitInfo *info = FUNCTION_VALUE_TO_JITINFO(args.calleev());
+ MOZ_ASSERT(info->type() == JSJitInfo::Getter);
+ JSJitGetterOp getter = info->getter;
+ bool ok = getter(cx, obj, self, JSJitGetterCallArgs(args));
+ #ifdef DEBUG
+ if (ok) {
+ AssertReturnTypeMatchesJitinfo(info, args.rval());
+ }
+ #endif
+ return ok;
+ """))
+
+
+class CGSpecializedGetter(CGAbstractStaticMethod):
+ """
+ A class for generating the code for a specialized attribute getter
+ that the JIT can call with lower overhead.
+ """
+ def __init__(self, descriptor, attr):
+ self.attr = attr
+ name = 'get_' + IDLToCIdentifier(attr.identifier.name)
+ args = [
+ Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'obj'),
+ Argument('%s*' % descriptor.nativeType, 'self'),
+ Argument('JSJitGetterCallArgs', 'args')
+ ]
+ CGAbstractStaticMethod.__init__(self, descriptor, name, "bool", args)
+
+ def definition_body(self):
+ if self.attr.isMaplikeOrSetlikeAttr():
+ # If the interface is maplike/setlike, there will be one getter
+ # method for the size property of the backing object. Due to having
+ # to unpack the backing object from the slot, this requires its own
+ # generator.
+ return getMaplikeOrSetlikeSizeGetterBody(self.descriptor, self.attr)
+ nativeName = CGSpecializedGetter.makeNativeName(self.descriptor,
+ self.attr)
+ if self.attr.slotIndices is not None:
+ if self.descriptor.hasXPConnectImpls:
+ raise TypeError("Interface '%s' has XPConnect impls, so we "
+ "can't use our slot for property '%s'!" %
+ (self.descriptor.interface.identifier.name,
+ self.attr.identifier.name))
+
+ # We're going to store this return value in a slot on some object,
+ # to cache it. The question is, which object? For dictionary and
+ # sequence return values, we want to use a slot on the Xray expando
+ # if we're called via Xrays, and a slot on our reflector otherwise.
+ # On the other hand, when dealing with some interfacce types
+ # (navigator properties, window.document) we want to avoid calling
+ # the getter more than once. In the case of navigator properties
+ # that's because the getter actually creates a new object each time.
+ # In the case of window.document, it's because the getter can start
+ # returning null, which would get hidden in he non-Xray case by the
+ # fact that it's [StoreOnSlot], so the cached version is always
+ # around.
+ #
+ # The upshot is that we use the reflector slot for any getter whose
+ # type is a gecko interface, whether we're called via Xrays or not.
+ # Since [Cached] and [StoreInSlot] cannot be used with "NewObject",
+ # we know that in the interface type case the returned object is
+ # wrappercached. So creating Xrays to it is reasonable.
+ if mayUseXrayExpandoSlots(self.descriptor, self.attr):
+ prefix = fill(
+ """
+ // Have to either root across the getter call or reget after.
+ bool isXray;
+ JS::Rooted<JSObject*> slotStorage(cx, GetCachedSlotStorageObject(cx, obj, &isXray));
+ if (!slotStorage) {
+ return false;
+ }
+ const size_t slotIndex = isXray ? ${xraySlotIndex} : ${slotIndex};
+ """,
+ xraySlotIndex=memberXrayExpandoReservedSlot(self.attr,
+ self.descriptor),
+ slotIndex=memberReservedSlot(self.attr, self.descriptor))
+ else:
+ prefix = fill(
+ """
+ // Have to either root across the getter call or reget after.
+ JS::Rooted<JSObject*> slotStorage(cx, js::UncheckedUnwrap(obj, /* stopAtWindowProxy = */ false));
+ MOZ_ASSERT(IsDOMObject(slotStorage));
+ const size_t slotIndex = ${slotIndex};
+ """,
+ slotIndex=memberReservedSlot(self.attr, self.descriptor))
+
+ prefix += fill(
+ """
+ MOZ_ASSERT(JSCLASS_RESERVED_SLOTS(js::GetObjectClass(slotStorage)) > slotIndex);
+ {
+ // Scope for cachedVal
+ JS::Value cachedVal = js::GetReservedSlot(slotStorage, slotIndex);
+ if (!cachedVal.isUndefined()) {
+ args.rval().set(cachedVal);
+ // The cached value is in the compartment of slotStorage,
+ // so wrap into the caller compartment as needed.
+ return ${maybeWrap}(cx, args.rval());
+ }
+ }
+
+ """,
+ maybeWrap=getMaybeWrapValueFuncForType(self.attr.type))
+ else:
+ prefix = ""
+
+ if self.attr.navigatorObjectGetter:
+ cgGetterCall = CGNavigatorGetterCall
+ else:
+ cgGetterCall = CGGetterCall
+ return (prefix +
+ cgGetterCall(self.attr.type, nativeName,
+ self.descriptor, self.attr).define())
+
+ @staticmethod
+ def makeNativeName(descriptor, attr):
+ name = attr.identifier.name
+ nativeName = MakeNativeName(descriptor.binaryNameFor(name))
+ _, resultOutParam, _, _, _ = getRetvalDeclarationForType(attr.type,
+ descriptor)
+ infallible = ('infallible' in
+ descriptor.getExtendedAttributes(attr, getter=True))
+ if resultOutParam or attr.type.nullable() or not infallible:
+ nativeName = "Get" + nativeName
+ return nativeName
+
+
+class CGStaticGetter(CGAbstractStaticBindingMethod):
+ """
+ A class for generating the C++ code for an IDL static attribute getter.
+ """
+ def __init__(self, descriptor, attr):
+ self.attr = attr
+ name = 'get_' + IDLToCIdentifier(attr.identifier.name)
+ CGAbstractStaticBindingMethod.__init__(self, descriptor, name)
+
+ def generate_code(self):
+ nativeName = CGSpecializedGetter.makeNativeName(self.descriptor,
+ self.attr)
+ return CGGetterCall(self.attr.type, nativeName, self.descriptor,
+ self.attr)
+
+
+class CGGenericSetter(CGAbstractBindingMethod):
+ """
+ A class for generating the C++ code for an IDL attribute setter.
+ """
+ def __init__(self, descriptor, lenientThis=False, allowCrossOriginThis=False):
+ if lenientThis:
+ name = "genericLenientSetter"
+ unwrapFailureCode = dedent("""
+ MOZ_ASSERT(!JS_IsExceptionPending(cx));
+ if (!ReportLenientThisUnwrappingFailure(cx, &args.callee())) {
+ return false;
+ }
+ args.rval().set(JS::UndefinedValue());
+ return true;
+ """)
+ else:
+ if allowCrossOriginThis:
+ name = "genericCrossOriginSetter"
+ else:
+ name = "genericSetter"
+ unwrapFailureCode = (
+ 'return ThrowInvalidThis(cx, args, %%(securityError)s, "%s");\n' %
+ descriptor.interface.identifier.name)
+
+ CGAbstractBindingMethod.__init__(self, descriptor, name, JSNativeArguments(),
+ unwrapFailureCode,
+ allowCrossOriginThis=allowCrossOriginThis)
+
+ def generate_code(self):
+ return CGGeneric(fill(
+ """
+ if (args.length() == 0) {
+ return ThrowErrorMessage(cx, MSG_MISSING_ARGUMENTS, "${name} attribute setter");
+ }
+ const JSJitInfo *info = FUNCTION_VALUE_TO_JITINFO(args.calleev());
+ MOZ_ASSERT(info->type() == JSJitInfo::Setter);
+ JSJitSetterOp setter = info->setter;
+ if (!setter(cx, obj, self, JSJitSetterCallArgs(args))) {
+ return false;
+ }
+ args.rval().setUndefined();
+ #ifdef DEBUG
+ AssertReturnTypeMatchesJitinfo(info, args.rval());
+ #endif
+ return true;
+ """,
+ name=self.descriptor.interface.identifier.name))
+
+
+class CGSpecializedSetter(CGAbstractStaticMethod):
+ """
+ A class for generating the code for a specialized attribute setter
+ that the JIT can call with lower overhead.
+ """
+ def __init__(self, descriptor, attr):
+ self.attr = attr
+ name = 'set_' + IDLToCIdentifier(attr.identifier.name)
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'obj'),
+ Argument('%s*' % descriptor.nativeType, 'self'),
+ Argument('JSJitSetterCallArgs', 'args')]
+ CGAbstractStaticMethod.__init__(self, descriptor, name, "bool", args)
+
+ def definition_body(self):
+ nativeName = CGSpecializedSetter.makeNativeName(self.descriptor,
+ self.attr)
+ return CGSetterCall(self.attr.type, nativeName, self.descriptor,
+ self.attr).define()
+
+ @staticmethod
+ def makeNativeName(descriptor, attr):
+ name = attr.identifier.name
+ return "Set" + MakeNativeName(descriptor.binaryNameFor(name))
+
+
+class CGStaticSetter(CGAbstractStaticBindingMethod):
+ """
+ A class for generating the C++ code for an IDL static attribute setter.
+ """
+ def __init__(self, descriptor, attr):
+ self.attr = attr
+ name = 'set_' + IDLToCIdentifier(attr.identifier.name)
+ CGAbstractStaticBindingMethod.__init__(self, descriptor, name)
+
+ def generate_code(self):
+ nativeName = CGSpecializedSetter.makeNativeName(self.descriptor,
+ self.attr)
+ checkForArg = CGGeneric(fill(
+ """
+ if (args.length() == 0) {
+ return ThrowErrorMessage(cx, MSG_MISSING_ARGUMENTS, "${name} setter");
+ }
+ """,
+ name=self.attr.identifier.name))
+ call = CGSetterCall(self.attr.type, nativeName, self.descriptor,
+ self.attr)
+ return CGList([checkForArg, call])
+
+
+class CGSpecializedForwardingSetter(CGSpecializedSetter):
+ """
+ A class for generating the code for a specialized attribute setter with
+ PutForwards that the JIT can call with lower overhead.
+ """
+ def __init__(self, descriptor, attr):
+ CGSpecializedSetter.__init__(self, descriptor, attr)
+
+ def definition_body(self):
+ attrName = self.attr.identifier.name
+ forwardToAttrName = self.attr.getExtendedAttribute("PutForwards")[0]
+ # JS_GetProperty and JS_SetProperty can only deal with ASCII
+ assert all(ord(c) < 128 for c in attrName)
+ assert all(ord(c) < 128 for c in forwardToAttrName)
+ return fill(
+ """
+ JS::Rooted<JS::Value> v(cx);
+ if (!JS_GetProperty(cx, obj, "${attr}", &v)) {
+ return false;
+ }
+
+ if (!v.isObject()) {
+ return ThrowErrorMessage(cx, MSG_NOT_OBJECT, "${interface}.${attr}");
+ }
+
+ JS::Rooted<JSObject*> targetObj(cx, &v.toObject());
+ return JS_SetProperty(cx, targetObj, "${forwardToAttrName}", args[0]);
+ """,
+ attr=attrName,
+ interface=self.descriptor.interface.identifier.name,
+ forwardToAttrName=forwardToAttrName)
+
+
+class CGSpecializedReplaceableSetter(CGSpecializedSetter):
+ """
+ A class for generating the code for a specialized attribute setter with
+ Replaceable that the JIT can call with lower overhead.
+ """
+ def __init__(self, descriptor, attr):
+ CGSpecializedSetter.__init__(self, descriptor, attr)
+
+ def definition_body(self):
+ attrName = self.attr.identifier.name
+ # JS_DefineProperty can only deal with ASCII
+ assert all(ord(c) < 128 for c in attrName)
+ return ('return JS_DefineProperty(cx, obj, "%s", args[0], JSPROP_ENUMERATE);\n' %
+ attrName)
+
+
+class CGSpecializedLenientSetter(CGSpecializedSetter):
+ """
+ A class for generating the code for a specialized attribute setter with
+ LenientSetter that the JIT can call with lower overhead.
+ """
+ def __init__(self, descriptor, attr):
+ CGSpecializedSetter.__init__(self, descriptor, attr)
+
+ def definition_body(self):
+ attrName = self.attr.identifier.name
+ # JS_DefineProperty can only deal with ASCII
+ assert all(ord(c) < 128 for c in attrName)
+ return dedent("""
+ DeprecationWarning(cx, obj, nsIDocument::eLenientSetter);
+ return true;
+ """)
+
+
+def memberReturnsNewObject(member):
+ return member.getExtendedAttribute("NewObject") is not None
+
+
+class CGMemberJITInfo(CGThing):
+ """
+ A class for generating the JITInfo for a property that points to
+ our specialized getter and setter.
+ """
+ def __init__(self, descriptor, member):
+ self.member = member
+ self.descriptor = descriptor
+
+ def declare(self):
+ return ""
+
+ def defineJitInfo(self, infoName, opName, opType, infallible, movable,
+ eliminatable, aliasSet, alwaysInSlot, lazilyInSlot,
+ slotIndex, returnTypes, args):
+ """
+ aliasSet is a JSJitInfo::AliasSet value, without the "JSJitInfo::" bit.
+
+ args is None if we don't want to output argTypes for some
+ reason (e.g. we have overloads or we're not a method) and
+ otherwise an iterable of the arguments for this method.
+ """
+ assert(not movable or aliasSet != "AliasEverything") # Can't move write-aliasing things
+ assert(not alwaysInSlot or movable) # Things always in slots had better be movable
+ assert(not eliminatable or aliasSet != "AliasEverything") # Can't eliminate write-aliasing things
+ assert(not alwaysInSlot or eliminatable) # Things always in slots had better be eliminatable
+
+ def jitInfoInitializer(isTypedMethod):
+ initializer = fill(
+ """
+ {
+ { ${opName} },
+ { prototypes::id::${name} },
+ { PrototypeTraits<prototypes::id::${name}>::Depth },
+ JSJitInfo::${opType},
+ JSJitInfo::${aliasSet}, /* aliasSet. Not relevant for setters. */
+ ${returnType}, /* returnType. Not relevant for setters. */
+ ${isInfallible}, /* isInfallible. False in setters. */
+ ${isMovable}, /* isMovable. Not relevant for setters. */
+ ${isEliminatable}, /* isEliminatable. Not relevant for setters. */
+ ${isAlwaysInSlot}, /* isAlwaysInSlot. Only relevant for getters. */
+ ${isLazilyCachedInSlot}, /* isLazilyCachedInSlot. Only relevant for getters. */
+ ${isTypedMethod}, /* isTypedMethod. Only relevant for methods. */
+ ${slotIndex} /* Reserved slot index, if we're stored in a slot, else 0. */
+ }
+ """,
+ opName=opName,
+ name=self.descriptor.name,
+ opType=opType,
+ aliasSet=aliasSet,
+ returnType=reduce(CGMemberJITInfo.getSingleReturnType, returnTypes,
+ ""),
+ isInfallible=toStringBool(infallible),
+ isMovable=toStringBool(movable),
+ isEliminatable=toStringBool(eliminatable),
+ isAlwaysInSlot=toStringBool(alwaysInSlot),
+ isLazilyCachedInSlot=toStringBool(lazilyInSlot),
+ isTypedMethod=toStringBool(isTypedMethod),
+ slotIndex=slotIndex)
+ return initializer.rstrip()
+
+ slotAssert = fill(
+ """
+ static_assert(${slotIndex} <= JSJitInfo::maxSlotIndex, "We won't fit");
+ static_assert(${slotIndex} < ${classReservedSlots}, "There is no slot for us");
+ """,
+ slotIndex=slotIndex,
+ classReservedSlots=INSTANCE_RESERVED_SLOTS + self.descriptor.interface.totalMembersInSlots)
+ if args is not None:
+ argTypes = "%s_argTypes" % infoName
+ args = [CGMemberJITInfo.getJSArgType(arg.type) for arg in args]
+ args.append("JSJitInfo::ArgTypeListEnd")
+ argTypesDecl = (
+ "static const JSJitInfo::ArgType %s[] = { %s };\n" %
+ (argTypes, ", ".join(args)))
+ return fill(
+ """
+ $*{argTypesDecl}
+ static const JSTypedMethodJitInfo ${infoName} = {
+ ${jitInfo},
+ ${argTypes}
+ };
+ $*{slotAssert}
+ """,
+ argTypesDecl=argTypesDecl,
+ infoName=infoName,
+ jitInfo=indent(jitInfoInitializer(True)),
+ argTypes=argTypes,
+ slotAssert=slotAssert)
+
+ return fill(
+ """
+ static const JSJitInfo ${infoName} = ${jitInfo};
+ $*{slotAssert}
+ """,
+ infoName=infoName,
+ jitInfo=jitInfoInitializer(False),
+ slotAssert=slotAssert)
+
+ def define(self):
+ if self.member.isAttr():
+ getterinfo = ("%s_getterinfo" %
+ IDLToCIdentifier(self.member.identifier.name))
+ # We need the cast here because JSJitGetterOp has a "void* self"
+ # while we have the right type.
+ getter = ("(JSJitGetterOp)get_%s" %
+ IDLToCIdentifier(self.member.identifier.name))
+ getterinfal = "infallible" in self.descriptor.getExtendedAttributes(self.member, getter=True)
+
+ movable = self.mayBeMovable() and getterinfal
+ eliminatable = self.mayBeEliminatable() and getterinfal
+ aliasSet = self.aliasSet()
+
+ getterinfal = getterinfal and infallibleForMember(self.member, self.member.type, self.descriptor)
+ isAlwaysInSlot = self.member.getExtendedAttribute("StoreInSlot")
+ if self.member.slotIndices is not None:
+ assert isAlwaysInSlot or self.member.getExtendedAttribute("Cached")
+ isLazilyCachedInSlot = not isAlwaysInSlot
+ slotIndex = memberReservedSlot(self.member, self.descriptor)
+ # We'll statically assert that this is not too big in
+ # CGUpdateMemberSlotsMethod, in the case when
+ # isAlwaysInSlot is true.
+ else:
+ isLazilyCachedInSlot = False
+ slotIndex = "0"
+
+ result = self.defineJitInfo(getterinfo, getter, "Getter",
+ getterinfal, movable, eliminatable,
+ aliasSet, isAlwaysInSlot,
+ isLazilyCachedInSlot, slotIndex,
+ [self.member.type], None)
+ if (not self.member.readonly or
+ self.member.getExtendedAttribute("PutForwards") is not None or
+ self.member.getExtendedAttribute("Replaceable") is not None or
+ self.member.getExtendedAttribute("LenientSetter") is not None):
+ setterinfo = ("%s_setterinfo" %
+ IDLToCIdentifier(self.member.identifier.name))
+ # Actually a JSJitSetterOp, but JSJitGetterOp is first in the
+ # union.
+ setter = ("(JSJitGetterOp)set_%s" %
+ IDLToCIdentifier(self.member.identifier.name))
+ # Setters are always fallible, since they have to do a typed unwrap.
+ result += self.defineJitInfo(setterinfo, setter, "Setter",
+ False, False, False, "AliasEverything",
+ False, False, "0",
+ [BuiltinTypes[IDLBuiltinType.Types.void]],
+ None)
+ return result
+ if self.member.isMethod():
+ methodinfo = ("%s_methodinfo" %
+ IDLToCIdentifier(self.member.identifier.name))
+ name = CppKeywords.checkMethodName(
+ IDLToCIdentifier(self.member.identifier.name))
+ if self.member.returnsPromise():
+ name = CGMethodPromiseWrapper.makeName(name)
+ # Actually a JSJitMethodOp, but JSJitGetterOp is first in the union.
+ method = ("(JSJitGetterOp)%s" % name)
+
+ # Methods are infallible if they are infallible, have no arguments
+ # to unwrap, and have a return type that's infallible to wrap up for
+ # return.
+ sigs = self.member.signatures()
+ if len(sigs) != 1:
+ # Don't handle overloading. If there's more than one signature,
+ # one of them must take arguments.
+ methodInfal = False
+ args = None
+ movable = False
+ eliminatable = False
+ else:
+ sig = sigs[0]
+ # For methods that affect nothing, it's OK to set movable to our
+ # notion of infallible on the C++ side, without considering
+ # argument conversions, since argument conversions that can
+ # reliably throw would be effectful anyway and the jit doesn't
+ # move effectful things.
+ hasInfallibleImpl = "infallible" in self.descriptor.getExtendedAttributes(self.member)
+ movable = self.mayBeMovable() and hasInfallibleImpl
+ eliminatable = self.mayBeEliminatable() and hasInfallibleImpl
+ # XXXbz can we move the smarts about fallibility due to arg
+ # conversions into the JIT, using our new args stuff?
+ if (len(sig[1]) != 0 or
+ not infallibleForMember(self.member, sig[0], self.descriptor)):
+ # We have arguments or our return-value boxing can fail
+ methodInfal = False
+ else:
+ methodInfal = hasInfallibleImpl
+ # For now, only bother to output args if we're side-effect-free.
+ if self.member.affects == "Nothing":
+ args = sig[1]
+ else:
+ args = None
+
+ aliasSet = self.aliasSet()
+ result = self.defineJitInfo(methodinfo, method, "Method",
+ methodInfal, movable, eliminatable,
+ aliasSet, False, False, "0",
+ [s[0] for s in sigs], args)
+ return result
+ raise TypeError("Illegal member type to CGPropertyJITInfo")
+
+ def mayBeMovable(self):
+ """
+ Returns whether this attribute or method may be movable, just
+ based on Affects/DependsOn annotations.
+ """
+ affects = self.member.affects
+ dependsOn = self.member.dependsOn
+ assert affects in IDLInterfaceMember.AffectsValues
+ assert dependsOn in IDLInterfaceMember.DependsOnValues
+ # Things that are DependsOn=DeviceState are not movable, because we
+ # don't want them coalesced with each other or loop-hoisted, since
+ # their return value can change even if nothing is going on from our
+ # point of view.
+ return (affects == "Nothing" and
+ (dependsOn != "Everything" and dependsOn != "DeviceState"))
+
+ def mayBeEliminatable(self):
+ """
+ Returns whether this attribute or method may be eliminatable, just
+ based on Affects/DependsOn annotations.
+ """
+ # dependsOn shouldn't affect this decision at all, except in jitinfo we
+ # have no way to express "Depends on everything, affects nothing",
+ # because we only have three alias set values: AliasNone ("depends on
+ # nothing, affects nothing"), AliasDOMSets ("depends on DOM sets,
+ # affects nothing"), AliasEverything ("depends on everything, affects
+ # everything"). So the [Affects=Nothing, DependsOn=Everything] case
+ # gets encoded as AliasEverything and defineJitInfo asserts that if our
+ # alias state is AliasEverything then we're not eliminatable (because it
+ # thinks we might have side-effects at that point). Bug 1155796 is
+ # tracking possible solutions for this.
+ affects = self.member.affects
+ dependsOn = self.member.dependsOn
+ assert affects in IDLInterfaceMember.AffectsValues
+ assert dependsOn in IDLInterfaceMember.DependsOnValues
+ return affects == "Nothing" and dependsOn != "Everything"
+
+ def aliasSet(self):
+ """
+ Returns the alias set to store in the jitinfo. This may not be the
+ effective alias set the JIT uses, depending on whether we have enough
+ information about our args to allow the JIT to prove that effectful
+ argument conversions won't happen.
+ """
+ dependsOn = self.member.dependsOn
+ assert dependsOn in IDLInterfaceMember.DependsOnValues
+
+ if dependsOn == "Nothing" or dependsOn == "DeviceState":
+ assert self.member.affects == "Nothing"
+ return "AliasNone"
+
+ if dependsOn == "DOMState":
+ assert self.member.affects == "Nothing"
+ return "AliasDOMSets"
+
+ return "AliasEverything"
+
+ @staticmethod
+ def getJSReturnTypeTag(t):
+ if t.nullable():
+ # Sometimes it might return null, sometimes not
+ return "JSVAL_TYPE_UNKNOWN"
+ if t.isVoid():
+ # No return, every time
+ return "JSVAL_TYPE_UNDEFINED"
+ if t.isSequence():
+ return "JSVAL_TYPE_OBJECT"
+ if t.isMozMap():
+ return "JSVAL_TYPE_OBJECT"
+ if t.isGeckoInterface():
+ return "JSVAL_TYPE_OBJECT"
+ if t.isString():
+ return "JSVAL_TYPE_STRING"
+ if t.isEnum():
+ return "JSVAL_TYPE_STRING"
+ if t.isCallback():
+ return "JSVAL_TYPE_OBJECT"
+ if t.isAny():
+ # The whole point is to return various stuff
+ return "JSVAL_TYPE_UNKNOWN"
+ if t.isObject():
+ return "JSVAL_TYPE_OBJECT"
+ if t.isSpiderMonkeyInterface():
+ return "JSVAL_TYPE_OBJECT"
+ if t.isUnion():
+ u = t.unroll()
+ if u.hasNullableType:
+ # Might be null or not
+ return "JSVAL_TYPE_UNKNOWN"
+ return reduce(CGMemberJITInfo.getSingleReturnType,
+ u.flatMemberTypes, "")
+ if t.isDictionary():
+ return "JSVAL_TYPE_OBJECT"
+ if t.isDate():
+ return "JSVAL_TYPE_OBJECT"
+ if not t.isPrimitive():
+ raise TypeError("No idea what type " + str(t) + " is.")
+ tag = t.tag()
+ if tag == IDLType.Tags.bool:
+ return "JSVAL_TYPE_BOOLEAN"
+ if tag in [IDLType.Tags.int8, IDLType.Tags.uint8,
+ IDLType.Tags.int16, IDLType.Tags.uint16,
+ IDLType.Tags.int32]:
+ return "JSVAL_TYPE_INT32"
+ if tag in [IDLType.Tags.int64, IDLType.Tags.uint64,
+ IDLType.Tags.unrestricted_float, IDLType.Tags.float,
+ IDLType.Tags.unrestricted_double, IDLType.Tags.double]:
+ # These all use JS_NumberValue, which can return int or double.
+ # But TI treats "double" as meaning "int or double", so we're
+ # good to return JSVAL_TYPE_DOUBLE here.
+ return "JSVAL_TYPE_DOUBLE"
+ if tag != IDLType.Tags.uint32:
+ raise TypeError("No idea what type " + str(t) + " is.")
+ # uint32 is sometimes int and sometimes double.
+ return "JSVAL_TYPE_DOUBLE"
+
+ @staticmethod
+ def getSingleReturnType(existingType, t):
+ type = CGMemberJITInfo.getJSReturnTypeTag(t)
+ if existingType == "":
+ # First element of the list; just return its type
+ return type
+
+ if type == existingType:
+ return existingType
+ if ((type == "JSVAL_TYPE_DOUBLE" and
+ existingType == "JSVAL_TYPE_INT32") or
+ (existingType == "JSVAL_TYPE_DOUBLE" and
+ type == "JSVAL_TYPE_INT32")):
+ # Promote INT32 to DOUBLE as needed
+ return "JSVAL_TYPE_DOUBLE"
+ # Different types
+ return "JSVAL_TYPE_UNKNOWN"
+
+ @staticmethod
+ def getJSArgType(t):
+ assert not t.isVoid()
+ if t.nullable():
+ # Sometimes it might return null, sometimes not
+ return "JSJitInfo::ArgType(JSJitInfo::Null | %s)" % CGMemberJITInfo.getJSArgType(t.inner)
+ if t.isSequence():
+ return "JSJitInfo::Object"
+ if t.isGeckoInterface():
+ return "JSJitInfo::Object"
+ if t.isString():
+ return "JSJitInfo::String"
+ if t.isEnum():
+ return "JSJitInfo::String"
+ if t.isCallback():
+ return "JSJitInfo::Object"
+ if t.isAny():
+ # The whole point is to return various stuff
+ return "JSJitInfo::Any"
+ if t.isObject():
+ return "JSJitInfo::Object"
+ if t.isSpiderMonkeyInterface():
+ return "JSJitInfo::Object"
+ if t.isUnion():
+ u = t.unroll()
+ type = "JSJitInfo::Null" if u.hasNullableType else ""
+ return ("JSJitInfo::ArgType(%s)" %
+ reduce(CGMemberJITInfo.getSingleArgType,
+ u.flatMemberTypes, type))
+ if t.isDictionary():
+ return "JSJitInfo::Object"
+ if t.isDate():
+ return "JSJitInfo::Object"
+ if not t.isPrimitive():
+ raise TypeError("No idea what type " + str(t) + " is.")
+ tag = t.tag()
+ if tag == IDLType.Tags.bool:
+ return "JSJitInfo::Boolean"
+ if tag in [IDLType.Tags.int8, IDLType.Tags.uint8,
+ IDLType.Tags.int16, IDLType.Tags.uint16,
+ IDLType.Tags.int32]:
+ return "JSJitInfo::Integer"
+ if tag in [IDLType.Tags.int64, IDLType.Tags.uint64,
+ IDLType.Tags.unrestricted_float, IDLType.Tags.float,
+ IDLType.Tags.unrestricted_double, IDLType.Tags.double]:
+ # These all use JS_NumberValue, which can return int or double.
+ # But TI treats "double" as meaning "int or double", so we're
+ # good to return JSVAL_TYPE_DOUBLE here.
+ return "JSJitInfo::Double"
+ if tag != IDLType.Tags.uint32:
+ raise TypeError("No idea what type " + str(t) + " is.")
+ # uint32 is sometimes int and sometimes double.
+ return "JSJitInfo::Double"
+
+ @staticmethod
+ def getSingleArgType(existingType, t):
+ type = CGMemberJITInfo.getJSArgType(t)
+ if existingType == "":
+ # First element of the list; just return its type
+ return type
+
+ if type == existingType:
+ return existingType
+ return "%s | %s" % (existingType, type)
+
+
+class CGStaticMethodJitinfo(CGGeneric):
+ """
+ A class for generating the JITInfo for a promise-returning static method.
+ """
+ def __init__(self, method):
+ CGGeneric.__init__(
+ self,
+ "\n"
+ "static const JSJitInfo %s_methodinfo = {\n"
+ " { (JSJitGetterOp)%s },\n"
+ " { prototypes::id::_ID_Count }, { 0 }, JSJitInfo::StaticMethod,\n"
+ " JSJitInfo::AliasEverything, JSVAL_TYPE_MISSING, false, false,\n"
+ " false, false, 0\n"
+ "};\n" %
+ (IDLToCIdentifier(method.identifier.name),
+ CppKeywords.checkMethodName(
+ IDLToCIdentifier(method.identifier.name))))
+
+
+def getEnumValueName(value):
+ # Some enum values can be empty strings. Others might have weird
+ # characters in them. Deal with the former by returning "_empty",
+ # deal with possible name collisions from that by throwing if the
+ # enum value is actually "_empty", and throw on any value
+ # containing non-ASCII chars for now. Replace all chars other than
+ # [0-9A-Za-z_] with '_'.
+ if re.match("[^\x20-\x7E]", value):
+ raise SyntaxError('Enum value "' + value + '" contains non-ASCII characters')
+ if re.match("^[0-9]", value):
+ return '_' + value
+ value = re.sub(r'[^0-9A-Za-z_]', '_', value)
+ if re.match("^_[A-Z]|__", value):
+ raise SyntaxError('Enum value "' + value + '" is reserved by the C++ spec')
+ if value == "_empty":
+ raise SyntaxError('"_empty" is not an IDL enum value we support yet')
+ if value == "":
+ return "_empty"
+ nativeName = MakeNativeName(value)
+ if nativeName == "EndGuard_":
+ raise SyntaxError('Enum value "' + value + '" cannot be used because it'
+ ' collides with our internal EndGuard_ value. Please'
+ ' rename our internal EndGuard_ to something else')
+ return nativeName
+
+class CGEnumToJSValue(CGAbstractMethod):
+ def __init__(self, enum):
+ enumType = enum.identifier.name
+ self.stringsArray = enumType + "Values::" + ENUM_ENTRY_VARIABLE_NAME
+ CGAbstractMethod.__init__(self, None, "ToJSValue", "bool",
+ [Argument("JSContext*", "aCx"),
+ Argument(enumType, "aArgument"),
+ Argument("JS::MutableHandle<JS::Value>",
+ "aValue")])
+
+ def definition_body(self):
+ return fill(
+ """
+ MOZ_ASSERT(uint32_t(aArgument) < ArrayLength(${strings}));
+ JSString* resultStr =
+ JS_NewStringCopyN(aCx, ${strings}[uint32_t(aArgument)].value,
+ ${strings}[uint32_t(aArgument)].length);
+ if (!resultStr) {
+ return false;
+ }
+ aValue.setString(resultStr);
+ return true;
+ """,
+ strings=self.stringsArray)
+
+
+class CGEnum(CGThing):
+ def __init__(self, enum):
+ CGThing.__init__(self)
+ self.enum = enum
+ strings = CGNamespace(
+ self.stringsNamespace(),
+ CGGeneric(declare=("extern const EnumEntry %s[%d];\n" %
+ (ENUM_ENTRY_VARIABLE_NAME, self.nEnumStrings())),
+ define=fill(
+ """
+ extern const EnumEntry ${name}[${count}] = {
+ $*{entries}
+ { nullptr, 0 }
+ };
+ """,
+ name=ENUM_ENTRY_VARIABLE_NAME,
+ count=self.nEnumStrings(),
+ entries=''.join('{"%s", %d},\n' % (val, len(val))
+ for val in self.enum.values()))))
+ toJSValue = CGEnumToJSValue(enum)
+ self.cgThings = CGList([strings, toJSValue], "\n")
+
+ def stringsNamespace(self):
+ return self.enum.identifier.name + "Values"
+
+ def nEnumStrings(self):
+ return len(self.enum.values()) + 1
+
+ def declare(self):
+ decl = fill(
+ """
+ enum class ${name} : uint32_t {
+ $*{enums}
+ EndGuard_
+ };
+ """,
+ name=self.enum.identifier.name,
+ enums=",\n".join(map(getEnumValueName, self.enum.values())) + ",\n")
+ strings = CGNamespace(self.stringsNamespace(),
+ CGGeneric(declare="extern const EnumEntry %s[%d];\n"
+ % (ENUM_ENTRY_VARIABLE_NAME, self.nEnumStrings())))
+ return decl + "\n" + self.cgThings.declare()
+
+ def define(self):
+ return self.cgThings.define()
+
+ def deps(self):
+ return self.enum.getDeps()
+
+
+def getUnionAccessorSignatureType(type, descriptorProvider):
+ """
+ Returns the types that are used in the getter and setter signatures for
+ union types
+ """
+ # Flat member types have already unwrapped nullables.
+ assert not type.nullable()
+
+ if type.isSequence() or type.isMozMap():
+ if type.isSequence():
+ wrapperType = "Sequence"
+ else:
+ wrapperType = "MozMap"
+ # We don't use the returned template here, so it's OK to just pass no
+ # sourceDescription.
+ elementInfo = getJSToNativeConversionInfo(type.inner,
+ descriptorProvider,
+ isMember=wrapperType)
+ return CGTemplatedType(wrapperType, elementInfo.declType,
+ isConst=True, isReference=True)
+
+ # Nested unions are unwrapped automatically into our flatMemberTypes.
+ assert not type.isUnion()
+
+ if type.isGeckoInterface():
+ descriptor = descriptorProvider.getDescriptor(
+ type.unroll().inner.identifier.name)
+ typeName = CGGeneric(descriptor.nativeType)
+ # Allow null pointers for old-binding classes.
+ if type.unroll().inner.isExternal():
+ typeName = CGWrapper(typeName, post="*")
+ else:
+ typeName = CGWrapper(typeName, post="&")
+ return typeName
+
+ if type.isSpiderMonkeyInterface():
+ typeName = CGGeneric(type.name)
+ return CGWrapper(typeName, post=" const &")
+
+ if type.isDOMString() or type.isUSVString():
+ return CGGeneric("const nsAString&")
+
+ if type.isByteString():
+ return CGGeneric("const nsCString&")
+
+ if type.isEnum():
+ return CGGeneric(type.inner.identifier.name)
+
+ if type.isCallback():
+ return CGGeneric("%s&" % type.unroll().callback.identifier.name)
+
+ if type.isAny():
+ return CGGeneric("JS::Value")
+
+ if type.isObject():
+ return CGGeneric("JSObject*")
+
+ if type.isDictionary():
+ return CGGeneric("const %s&" % type.inner.identifier.name)
+
+ if not type.isPrimitive():
+ raise TypeError("Need native type for argument type '%s'" % str(type))
+
+ return CGGeneric(builtinNames[type.tag()])
+
+
+def getUnionTypeTemplateVars(unionType, type, descriptorProvider,
+ ownsMembers=False):
+ name = getUnionMemberName(type)
+ holderName = "m" + name + "Holder"
+
+ # By the time tryNextCode is invoked, we're guaranteed the union has been
+ # constructed as some type, since we've been trying to convert into the
+ # corresponding member.
+ prefix = "" if ownsMembers else "mUnion."
+ tryNextCode = ("$*{destroyHolder}\n"
+ "%sDestroy%s();\n"
+ "tryNext = true;\n"
+ "return true;\n" % (prefix, name))
+
+ conversionInfo = getJSToNativeConversionInfo(
+ type, descriptorProvider, failureCode=tryNextCode,
+ isDefinitelyObject=not type.isDictionary(),
+ isMember=("OwningUnion" if ownsMembers else None),
+ sourceDescription="member of %s" % unionType)
+
+ if conversionInfo.holderType is not None:
+ assert not ownsMembers
+ destroyHolder = "%s.reset();\n" % holderName
+ else:
+ destroyHolder = ""
+
+ ctorNeedsCx = conversionInfo.declArgs == "cx"
+ ctorArgs = "cx" if ctorNeedsCx else ""
+
+ structType = conversionInfo.declType.define()
+ externalType = getUnionAccessorSignatureType(type, descriptorProvider).define()
+
+ if type.isObject():
+ if ownsMembers:
+ body = dedent("""
+ MOZ_ASSERT(mType == eUninitialized);
+ mValue.mObject.SetValue(obj);
+ mType = eObject;
+ """)
+ else:
+ body = dedent("""
+ MOZ_ASSERT(mUnion.mType == mUnion.eUninitialized);
+ mUnion.mValue.mObject.SetValue(cx, obj);
+ mUnion.mType = mUnion.eObject;
+ """)
+
+ # It's a bit sketchy to do the security check after setting the value,
+ # but it keeps the code cleaner and lets us avoid rooting |obj| over the
+ # call to CallerSubsumes().
+ body = body + dedent("""
+ if (passedToJSImpl && !CallerSubsumes(obj)) {
+ ThrowErrorMessage(cx, MSG_PERMISSION_DENIED_TO_PASS_ARG, "%s");
+ return false;
+ }
+ return true;
+ """)
+
+ setter = ClassMethod("SetToObject", "bool",
+ [Argument("JSContext*", "cx"),
+ Argument("JSObject*", "obj"),
+ Argument("bool", "passedToJSImpl", default="false")],
+ inline=True, bodyInHeader=True,
+ body=body)
+
+ else:
+ # Important: we need to not have our declName involve
+ # maybe-GCing operations.
+ if conversionInfo.holderType is not None:
+ holderArgs = conversionInfo.holderArgs
+ if holderArgs is None:
+ holderArgs = ""
+ initHolder = "%s.emplace(%s);\n" % (holderName, holderArgs)
+ else:
+ initHolder = ""
+
+ jsConversion = fill(
+ initHolder + conversionInfo.template,
+ val="value",
+ maybeMutableVal="value",
+ declName="memberSlot",
+ holderName=(holderName if ownsMembers else "%s.ref()" % holderName),
+ destroyHolder=destroyHolder,
+ passedToJSImpl="passedToJSImpl")
+
+ jsConversion = fill(
+ """
+ tryNext = false;
+ { // scope for memberSlot
+ ${structType}& memberSlot = RawSetAs${name}(${ctorArgs});
+ $*{jsConversion}
+ }
+ return true;
+ """,
+ structType=structType,
+ name=name,
+ ctorArgs=ctorArgs,
+ jsConversion=jsConversion)
+
+ if ownsMembers:
+ handleType = "JS::Handle<JS::Value>"
+ else:
+ handleType = "JS::MutableHandle<JS::Value>"
+
+ setter = ClassMethod("TrySetTo" + name, "bool",
+ [Argument("JSContext*", "cx"),
+ Argument(handleType, "value"),
+ Argument("bool&", "tryNext"),
+ Argument("bool", "passedToJSImpl", default="false")],
+ inline=not ownsMembers,
+ bodyInHeader=not ownsMembers,
+ body=jsConversion)
+
+ return {
+ "name": name,
+ "structType": structType,
+ "externalType": externalType,
+ "setter": setter,
+ "holderType": conversionInfo.holderType.define() if conversionInfo.holderType else None,
+ "ctorArgs": ctorArgs,
+ "ctorArgList": [Argument("JSContext*", "cx")] if ctorNeedsCx else []
+ }
+
+
+class CGUnionStruct(CGThing):
+ def __init__(self, type, descriptorProvider, ownsMembers=False):
+ CGThing.__init__(self)
+ self.type = type.unroll()
+ self.descriptorProvider = descriptorProvider
+ self.ownsMembers = ownsMembers
+ self.struct = self.getStruct()
+
+ def declare(self):
+ return self.struct.declare()
+
+ def define(self):
+ return self.struct.define()
+
+ def deps(self):
+ return self.type.getDeps()
+
+ def getStruct(self):
+
+ members = [ClassMember("mType", "Type", body="eUninitialized"),
+ ClassMember("mValue", "Value")]
+ ctor = ClassConstructor([], bodyInHeader=True, visibility="public",
+ explicit=True)
+
+ methods = []
+ enumValues = ["eUninitialized"]
+ toJSValCases = [CGCase("eUninitialized", CGGeneric("return false;\n"))]
+ destructorCases = [CGCase("eUninitialized", None)]
+ assignmentCases = [
+ CGCase("eUninitialized",
+ CGGeneric('MOZ_ASSERT(mType == eUninitialized,\n'
+ ' "We need to destroy ourselves?");\n'))]
+ traceCases = []
+ unionValues = []
+ if self.type.hasNullableType:
+ enumValues.append("eNull")
+ methods.append(ClassMethod("IsNull", "bool", [], const=True, inline=True,
+ body="return mType == eNull;\n",
+ bodyInHeader=True))
+ methods.append(ClassMethod("SetNull", "void", [], inline=True,
+ body=("Uninit();\n"
+ "mType = eNull;\n"),
+ bodyInHeader=True))
+ destructorCases.append(CGCase("eNull", None))
+ assignmentCases.append(CGCase("eNull",
+ CGGeneric("MOZ_ASSERT(mType == eUninitialized);\n"
+ "mType = eNull;\n")))
+ toJSValCases.append(CGCase("eNull", CGGeneric("rval.setNull();\n"
+ "return true;\n")))
+
+ hasObjectType = any(t.isObject() for t in self.type.flatMemberTypes)
+ for t in self.type.flatMemberTypes:
+ vars = getUnionTypeTemplateVars(self.type,
+ t, self.descriptorProvider,
+ ownsMembers=self.ownsMembers)
+ if vars["name"] != "Object" or self.ownsMembers:
+ body = fill(
+ """
+ if (mType == e${name}) {
+ return mValue.m${name}.Value();
+ }
+ %s
+ mType = e${name};
+ return mValue.m${name}.SetValue(${ctorArgs});
+ """,
+ **vars)
+
+ # bodyInHeader must be false for return values because they own
+ # their union members and we don't want include headers in
+ # UnionTypes.h just to call Addref/Release
+ methods.append(ClassMethod(
+ "RawSetAs" + vars["name"],
+ vars["structType"] + "&",
+ vars["ctorArgList"],
+ bodyInHeader=not self.ownsMembers,
+ body=body % "MOZ_ASSERT(mType == eUninitialized);"))
+ uninit = "Uninit();"
+ if hasObjectType and not self.ownsMembers:
+ uninit = 'MOZ_ASSERT(mType != eObject, "This will not play well with Rooted");\n' + uninit
+ methods.append(ClassMethod(
+ "SetAs" + vars["name"],
+ vars["structType"] + "&",
+ vars["ctorArgList"],
+ bodyInHeader=not self.ownsMembers,
+ body=body % uninit))
+ if self.ownsMembers:
+ methods.append(vars["setter"])
+ # Provide a SetStringData() method to support string defaults.
+ if t.isByteString():
+ methods.append(
+ ClassMethod("SetStringData", "void",
+ [Argument("const nsCString::char_type*", "aData"),
+ Argument("nsCString::size_type", "aLength")],
+ inline=True, bodyInHeader=True,
+ body="RawSetAs%s().Assign(aData, aLength);\n" % t.name))
+ elif t.isString():
+ methods.append(
+ ClassMethod("SetStringData", "void",
+ [Argument("const nsString::char_type*", "aData"),
+ Argument("nsString::size_type", "aLength")],
+ inline=True, bodyInHeader=True,
+ body="RawSetAs%s().Assign(aData, aLength);\n" % t.name))
+
+ body = fill(
+ """
+ MOZ_ASSERT(Is${name}(), "Wrong type!");
+ mValue.m${name}.Destroy();
+ mType = eUninitialized;
+ """,
+ **vars)
+ methods.append(ClassMethod("Destroy" + vars["name"],
+ "void",
+ [],
+ visibility="private",
+ bodyInHeader=not self.ownsMembers,
+ body=body))
+
+ body = fill("return mType == e${name};\n", **vars)
+ methods.append(ClassMethod("Is" + vars["name"],
+ "bool",
+ [],
+ const=True,
+ bodyInHeader=True,
+ body=body))
+
+ body = fill(
+ """
+ MOZ_ASSERT(Is${name}(), "Wrong type!");
+ return mValue.m${name}.Value();
+ """,
+ **vars)
+ # The non-const version of GetAs* returns our internal type
+ getterReturnType = "%s&" % vars["structType"]
+ methods.append(ClassMethod("GetAs" + vars["name"],
+ getterReturnType,
+ [],
+ bodyInHeader=True,
+ body=body))
+ # The const version of GetAs* returns our internal type
+ # for owning unions, but our external type for non-owning
+ # ones.
+ if self.ownsMembers:
+ getterReturnType = "%s const &" % vars["structType"]
+ else:
+ getterReturnType = vars["externalType"]
+ methods.append(ClassMethod("GetAs" + vars["name"],
+ getterReturnType,
+ [],
+ const=True,
+ bodyInHeader=True,
+ body=body))
+
+ unionValues.append(
+ fill("UnionMember<${structType} > m${name}", **vars))
+ enumValues.append("e" + vars["name"])
+
+ skipToJSVal = False
+ try:
+ toJSValCases.append(
+ CGCase("e" + vars["name"],
+ self.getConversionToJS(vars, t)))
+ except MethodNotNewObjectError:
+ # If we can't have a ToJSVal() because one of our members can
+ # only be returned from [NewObject] methods, then just skip
+ # generating ToJSVal.
+ skipToJSVal = True
+ destructorCases.append(
+ CGCase("e" + vars["name"],
+ CGGeneric("Destroy%s();\n" % vars["name"])))
+ assignmentCases.append(
+ CGCase("e" + vars["name"],
+ CGGeneric("SetAs%s() = aOther.GetAs%s();\n" %
+ (vars["name"], vars["name"]))))
+ if self.ownsMembers and typeNeedsRooting(t):
+ if t.isObject():
+ traceCases.append(
+ CGCase("e" + vars["name"],
+ CGGeneric('JS::UnsafeTraceRoot(trc, %s, "%s");\n' %
+ ("&mValue.m" + vars["name"] + ".Value()",
+ "mValue.m" + vars["name"]))))
+ elif t.isDictionary():
+ traceCases.append(
+ CGCase("e" + vars["name"],
+ CGGeneric("mValue.m%s.Value().TraceDictionary(trc);\n" %
+ vars["name"])))
+ elif t.isSequence():
+ traceCases.append(
+ CGCase("e" + vars["name"],
+ CGGeneric("DoTraceSequence(trc, mValue.m%s.Value());\n" %
+ vars["name"])))
+ elif t.isMozMap():
+ traceCases.append(
+ CGCase("e" + vars["name"],
+ CGGeneric("TraceMozMap(trc, mValue.m%s.Value());\n" %
+ vars["name"])))
+ else:
+ assert t.isSpiderMonkeyInterface()
+ traceCases.append(
+ CGCase("e" + vars["name"],
+ CGGeneric("mValue.m%s.Value().TraceSelf(trc);\n" %
+ vars["name"])))
+
+ dtor = CGSwitch("mType", destructorCases).define()
+
+ methods.append(ClassMethod("Uninit", "void", [],
+ visibility="public", body=dtor,
+ bodyInHeader=not self.ownsMembers,
+ inline=not self.ownsMembers))
+
+ if not skipToJSVal:
+ methods.append(
+ ClassMethod(
+ "ToJSVal",
+ "bool",
+ [
+ Argument("JSContext*", "cx"),
+ Argument("JS::Handle<JSObject*>", "scopeObj"),
+ Argument("JS::MutableHandle<JS::Value>", "rval")
+ ],
+ body=CGSwitch("mType", toJSValCases,
+ default=CGGeneric("return false;\n")).define() + "\nreturn false;\n",
+ const=True))
+
+ constructors = [ctor]
+ selfName = CGUnionStruct.unionTypeName(self.type, self.ownsMembers)
+ if self.ownsMembers:
+ if traceCases:
+ traceBody = CGSwitch("mType", traceCases,
+ default=CGGeneric("")).define()
+ else:
+ traceBody = ""
+ methods.append(ClassMethod("TraceUnion", "void",
+ [Argument("JSTracer*", "trc")],
+ body=traceBody))
+ if CGUnionStruct.isUnionCopyConstructible(self.type):
+ constructors.append(
+ ClassConstructor(
+ [Argument("const %s&" % selfName, "aOther")],
+ bodyInHeader=True,
+ visibility="public",
+ explicit=True,
+ body="*this = aOther;\n"))
+ methods.append(ClassMethod(
+ "operator=", "void",
+ [Argument("const %s&" % selfName, "aOther")],
+ body=CGSwitch("aOther.mType", assignmentCases).define()))
+ disallowCopyConstruction = False
+ else:
+ disallowCopyConstruction = True
+ else:
+ disallowCopyConstruction = True
+
+ if self.ownsMembers:
+ friend = " friend void ImplCycleCollectionUnlink(%s& aUnion);\n" % CGUnionStruct.unionTypeName(self.type, True)
+ else:
+ friend = " friend class %sArgument;\n" % str(self.type)
+
+ bases = [ClassBase("AllOwningUnionBase")] if self.ownsMembers else []
+ return CGClass(selfName,
+ bases=bases,
+ members=members,
+ constructors=constructors,
+ methods=methods,
+ disallowCopyConstruction=disallowCopyConstruction,
+ extradeclarations=friend,
+ destructor=ClassDestructor(visibility="public",
+ body="Uninit();\n",
+ bodyInHeader=True),
+ enums=[ClassEnum("Type", enumValues, visibility="private")],
+ unions=[ClassUnion("Value", unionValues, visibility="private")])
+
+ def getConversionToJS(self, templateVars, type):
+ assert not type.nullable() # flatMemberTypes never has nullable types
+ val = "mValue.m%(name)s.Value()" % templateVars
+ wrapCode = wrapForType(
+ type, self.descriptorProvider,
+ {
+ "jsvalRef": "rval",
+ "jsvalHandle": "rval",
+ "obj": "scopeObj",
+ "result": val,
+ "typedArraysAreStructs": True
+ })
+ return CGGeneric(wrapCode)
+
+ @staticmethod
+ def isUnionCopyConstructible(type):
+ return all(isTypeCopyConstructible(t) for t in type.flatMemberTypes)
+
+ @staticmethod
+ def unionTypeName(type, ownsMembers):
+ """
+ Returns a string name for this known union type.
+ """
+ assert type.isUnion() and not type.nullable()
+ return ("Owning" if ownsMembers else "") + type.name
+
+ @staticmethod
+ def unionTypeDecl(type, ownsMembers):
+ """
+ Returns a string for declaring this possibly-nullable union type.
+ """
+ assert type.isUnion()
+ nullable = type.nullable()
+ if nullable:
+ type = type.inner
+ decl = CGGeneric(CGUnionStruct.unionTypeName(type, ownsMembers))
+ if nullable:
+ decl = CGTemplatedType("Nullable", decl)
+ return decl.define()
+
+
+class CGUnionConversionStruct(CGThing):
+ def __init__(self, type, descriptorProvider):
+ CGThing.__init__(self)
+ self.type = type.unroll()
+ self.descriptorProvider = descriptorProvider
+
+ def declare(self):
+
+ structName = str(self.type)
+ members = [ClassMember("mUnion", structName + "&",
+ body="const_cast<%s&>(aUnion)" % structName)]
+ # Argument needs to be a const ref because that's all Maybe<> allows
+ ctor = ClassConstructor([Argument("const %s&" % structName, "aUnion")],
+ bodyInHeader=True,
+ visibility="public",
+ explicit=True)
+ methods = []
+
+ if self.type.hasNullableType:
+ methods.append(ClassMethod("SetNull", "bool", [],
+ body=("MOZ_ASSERT(mUnion.mType == mUnion.eUninitialized);\n"
+ "mUnion.mType = mUnion.eNull;\n"
+ "return true;\n"),
+ inline=True, bodyInHeader=True))
+
+ for t in self.type.flatMemberTypes:
+ vars = getUnionTypeTemplateVars(self.type,
+ t, self.descriptorProvider)
+ methods.append(vars["setter"])
+ if vars["name"] != "Object":
+ body = fill(
+ """
+ MOZ_ASSERT(mUnion.mType == mUnion.eUninitialized);
+ mUnion.mType = mUnion.e${name};
+ return mUnion.mValue.m${name}.SetValue(${ctorArgs});
+ """,
+ **vars)
+ methods.append(ClassMethod("RawSetAs" + vars["name"],
+ vars["structType"] + "&",
+ vars["ctorArgList"],
+ bodyInHeader=True,
+ body=body,
+ visibility="private"))
+ # Provide a SetStringData() method to support string defaults.
+ if t.isByteString():
+ methods.append(
+ ClassMethod("SetStringData", "void",
+ [Argument("const nsDependentCString::char_type*", "aData"),
+ Argument("nsDependentCString::size_type", "aLength")],
+ inline=True, bodyInHeader=True,
+ body="RawSetAs%s().Rebind(aData, aLength);\n" % t.name))
+ elif t.isString():
+ methods.append(
+ ClassMethod("SetStringData", "void",
+ [Argument("const nsDependentString::char_type*", "aData"),
+ Argument("nsDependentString::size_type", "aLength")],
+ inline=True, bodyInHeader=True,
+ body="RawSetAs%s().Rebind(aData, aLength);\n" % t.name))
+
+ if vars["holderType"] is not None:
+ holderType = CGTemplatedType("Maybe",
+ CGGeneric(vars["holderType"])).define()
+ members.append(ClassMember("m%sHolder" % vars["name"],
+ holderType))
+
+ return CGClass(structName + "Argument",
+ members=members,
+ constructors=[ctor],
+ methods=methods,
+ disallowCopyConstruction=True).declare()
+
+ def define(self):
+ return ""
+
+ def deps(self):
+ return set()
+
+
+class ClassItem:
+ """ Use with CGClass """
+ def __init__(self, name, visibility):
+ self.name = name
+ self.visibility = visibility
+
+ def declare(self, cgClass):
+ assert False
+
+ def define(self, cgClass):
+ assert False
+
+
+class ClassBase(ClassItem):
+ def __init__(self, name, visibility='public'):
+ ClassItem.__init__(self, name, visibility)
+
+ def declare(self, cgClass):
+ return '%s %s' % (self.visibility, self.name)
+
+ def define(self, cgClass):
+ # Only in the header
+ return ''
+
+
+class ClassMethod(ClassItem):
+ def __init__(self, name, returnType, args, inline=False, static=False,
+ virtual=False, const=False, bodyInHeader=False,
+ templateArgs=None, visibility='public', body=None,
+ breakAfterReturnDecl="\n",
+ breakAfterSelf="\n", override=False):
+ """
+ override indicates whether to flag the method as override
+ """
+ assert not override or virtual
+ assert not (override and static)
+ self.returnType = returnType
+ self.args = args
+ self.inline = inline or bodyInHeader
+ self.static = static
+ self.virtual = virtual
+ self.const = const
+ self.bodyInHeader = bodyInHeader
+ self.templateArgs = templateArgs
+ self.body = body
+ self.breakAfterReturnDecl = breakAfterReturnDecl
+ self.breakAfterSelf = breakAfterSelf
+ self.override = override
+ ClassItem.__init__(self, name, visibility)
+
+ def getDecorators(self, declaring):
+ decorators = []
+ if self.inline:
+ decorators.append('inline')
+ if declaring:
+ if self.static:
+ decorators.append('static')
+ if self.virtual:
+ decorators.append('virtual')
+ if decorators:
+ return ' '.join(decorators) + ' '
+ return ''
+
+ def getBody(self):
+ # Override me or pass a string to constructor
+ assert self.body is not None
+ return self.body
+
+ def declare(self, cgClass):
+ templateClause = ('template <%s>\n' % ', '.join(self.templateArgs)
+ if self.bodyInHeader and self.templateArgs else '')
+ args = ', '.join([a.declare() for a in self.args])
+ if self.bodyInHeader:
+ body = indent(self.getBody())
+ body = '\n{\n' + body + '}\n'
+ else:
+ body = ';\n'
+
+ return fill(
+ "${templateClause}${decorators}${returnType}${breakAfterReturnDecl}"
+ "${name}(${args})${const}${override}${body}"
+ "${breakAfterSelf}",
+ templateClause=templateClause,
+ decorators=self.getDecorators(True),
+ returnType=self.returnType,
+ breakAfterReturnDecl=self.breakAfterReturnDecl,
+ name=self.name,
+ args=args,
+ const=' const' if self.const else '',
+ override=' override' if self.override else '',
+ body=body,
+ breakAfterSelf=self.breakAfterSelf)
+
+ def define(self, cgClass):
+ if self.bodyInHeader:
+ return ''
+
+ templateArgs = cgClass.templateArgs
+ if templateArgs:
+ if cgClass.templateSpecialization:
+ templateArgs = \
+ templateArgs[len(cgClass.templateSpecialization):]
+
+ if templateArgs:
+ templateClause = \
+ 'template <%s>\n' % ', '.join([str(a) for a in templateArgs])
+ else:
+ templateClause = ''
+
+ return fill(
+ """
+ ${templateClause}${decorators}${returnType}
+ ${className}::${name}(${args})${const}
+ {
+ $*{body}
+ }
+ """,
+ templateClause=templateClause,
+ decorators=self.getDecorators(False),
+ returnType=self.returnType,
+ className=cgClass.getNameString(),
+ name=self.name,
+ args=', '.join([a.define() for a in self.args]),
+ const=' const' if self.const else '',
+ body=self.getBody())
+
+
+class ClassUsingDeclaration(ClassItem):
+ """
+ Used for importing a name from a base class into a CGClass
+
+ baseClass is the name of the base class to import the name from
+
+ name is the name to import
+
+ visibility determines the visibility of the name (public,
+ protected, private), defaults to public.
+ """
+ def __init__(self, baseClass, name, visibility='public'):
+ self.baseClass = baseClass
+ ClassItem.__init__(self, name, visibility)
+
+ def declare(self, cgClass):
+ return "using %s::%s;\n\n" % (self.baseClass, self.name)
+
+ def define(self, cgClass):
+ return ''
+
+
+class ClassConstructor(ClassItem):
+ """
+ Used for adding a constructor to a CGClass.
+
+ args is a list of Argument objects that are the arguments taken by the
+ constructor.
+
+ inline should be True if the constructor should be marked inline.
+
+ bodyInHeader should be True if the body should be placed in the class
+ declaration in the header.
+
+ visibility determines the visibility of the constructor (public,
+ protected, private), defaults to private.
+
+ explicit should be True if the constructor should be marked explicit.
+
+ baseConstructors is a list of strings containing calls to base constructors,
+ defaults to None.
+
+ body contains a string with the code for the constructor, defaults to empty.
+ """
+ def __init__(self, args, inline=False, bodyInHeader=False,
+ visibility="private", explicit=False, constexpr=False, baseConstructors=None,
+ body=""):
+ assert not (inline and constexpr)
+ assert not (bodyInHeader and constexpr)
+ self.args = args
+ self.inline = inline or bodyInHeader
+ self.bodyInHeader = bodyInHeader or constexpr
+ self.explicit = explicit
+ self.constexpr = constexpr
+ self.baseConstructors = baseConstructors or []
+ self.body = body
+ ClassItem.__init__(self, None, visibility)
+
+ def getDecorators(self, declaring):
+ decorators = []
+ if self.explicit:
+ decorators.append('explicit')
+ if self.inline and declaring:
+ decorators.append('inline')
+ if self.constexpr and declaring:
+ decorators.append('constexpr')
+ if decorators:
+ return ' '.join(decorators) + ' '
+ return ''
+
+ def getInitializationList(self, cgClass):
+ items = [str(c) for c in self.baseConstructors]
+ for m in cgClass.members:
+ if not m.static:
+ initialize = m.body
+ if initialize:
+ items.append(m.name + "(" + initialize + ")")
+
+ if len(items) > 0:
+ return '\n : ' + ',\n '.join(items)
+ return ''
+
+ def getBody(self):
+ return self.body
+
+ def declare(self, cgClass):
+ args = ', '.join([a.declare() for a in self.args])
+ if self.bodyInHeader:
+ body = self.getInitializationList(cgClass) + '\n{\n' + indent(self.getBody()) + '}\n'
+ else:
+ body = ';\n'
+
+ return fill(
+ "${decorators}${className}(${args})${body}\n",
+ decorators=self.getDecorators(True),
+ className=cgClass.getNameString(),
+ args=args,
+ body=body)
+
+ def define(self, cgClass):
+ if self.bodyInHeader:
+ return ''
+
+ return fill(
+ """
+ ${decorators}
+ ${className}::${className}(${args})${initializationList}
+ {
+ $*{body}
+ }
+ """,
+ decorators=self.getDecorators(False),
+ className=cgClass.getNameString(),
+ args=', '.join([a.define() for a in self.args]),
+ initializationList=self.getInitializationList(cgClass),
+ body=self.getBody())
+
+
+class ClassDestructor(ClassItem):
+ """
+ Used for adding a destructor to a CGClass.
+
+ inline should be True if the destructor should be marked inline.
+
+ bodyInHeader should be True if the body should be placed in the class
+ declaration in the header.
+
+ visibility determines the visibility of the destructor (public,
+ protected, private), defaults to private.
+
+ body contains a string with the code for the destructor, defaults to empty.
+
+ virtual determines whether the destructor is virtual, defaults to False.
+ """
+ def __init__(self, inline=False, bodyInHeader=False,
+ visibility="private", body='', virtual=False):
+ self.inline = inline or bodyInHeader
+ self.bodyInHeader = bodyInHeader
+ self.body = body
+ self.virtual = virtual
+ ClassItem.__init__(self, None, visibility)
+
+ def getDecorators(self, declaring):
+ decorators = []
+ if self.virtual and declaring:
+ decorators.append('virtual')
+ if self.inline and declaring:
+ decorators.append('inline')
+ if decorators:
+ return ' '.join(decorators) + ' '
+ return ''
+
+ def getBody(self):
+ return self.body
+
+ def declare(self, cgClass):
+ if self.bodyInHeader:
+ body = '\n{\n' + indent(self.getBody()) + '}\n'
+ else:
+ body = ';\n'
+
+ return fill(
+ "${decorators}~${className}()${body}\n",
+ decorators=self.getDecorators(True),
+ className=cgClass.getNameString(),
+ body=body)
+
+ def define(self, cgClass):
+ if self.bodyInHeader:
+ return ''
+ return fill(
+ """
+ ${decorators}
+ ${className}::~${className}()
+ {
+ $*{body}
+ }
+ """,
+ decorators=self.getDecorators(False),
+ className=cgClass.getNameString(),
+ body=self.getBody())
+
+
+class ClassMember(ClassItem):
+ def __init__(self, name, type, visibility="private", static=False,
+ body=None, hasIgnoreInitCheckFlag=False):
+ self.type = type
+ self.static = static
+ self.body = body
+ self.hasIgnoreInitCheckFlag = hasIgnoreInitCheckFlag;
+ ClassItem.__init__(self, name, visibility)
+
+ def declare(self, cgClass):
+ return '%s%s%s %s;\n' % ('static ' if self.static else '',
+ 'MOZ_INIT_OUTSIDE_CTOR '
+ if self.hasIgnoreInitCheckFlag else '',
+ self.type, self.name)
+
+ def define(self, cgClass):
+ if not self.static:
+ return ''
+ if self.body:
+ body = " = " + self.body
+ else:
+ body = ""
+ return '%s %s::%s%s;\n' % (self.type, cgClass.getNameString(),
+ self.name, body)
+
+
+class ClassTypedef(ClassItem):
+ def __init__(self, name, type, visibility="public"):
+ self.type = type
+ ClassItem.__init__(self, name, visibility)
+
+ def declare(self, cgClass):
+ return 'typedef %s %s;\n' % (self.type, self.name)
+
+ def define(self, cgClass):
+ # Only goes in the header
+ return ''
+
+
+class ClassEnum(ClassItem):
+ def __init__(self, name, entries, values=None, visibility="public"):
+ self.entries = entries
+ self.values = values
+ ClassItem.__init__(self, name, visibility)
+
+ def declare(self, cgClass):
+ entries = []
+ for i in range(0, len(self.entries)):
+ if not self.values or i >= len(self.values):
+ entry = '%s' % self.entries[i]
+ else:
+ entry = '%s = %s' % (self.entries[i], self.values[i])
+ entries.append(entry)
+ name = '' if not self.name else ' ' + self.name
+ return 'enum%s\n{\n%s\n};\n' % (name, indent(',\n'.join(entries)))
+
+ def define(self, cgClass):
+ # Only goes in the header
+ return ''
+
+
+class ClassUnion(ClassItem):
+ def __init__(self, name, entries, visibility="public"):
+ self.entries = [entry + ";\n" for entry in entries]
+ ClassItem.__init__(self, name, visibility)
+
+ def declare(self, cgClass):
+ return "union %s\n{\n%s\n};\n" % (self.name, indent(''.join(self.entries)))
+
+ def define(self, cgClass):
+ # Only goes in the header
+ return ''
+
+
+class CGClass(CGThing):
+ def __init__(self, name, bases=[], members=[], constructors=[],
+ destructor=None, methods=[],
+ typedefs=[], enums=[], unions=[], templateArgs=[],
+ templateSpecialization=[], isStruct=False,
+ disallowCopyConstruction=False, indent='',
+ decorators='',
+ extradeclarations='',
+ extradefinitions=''):
+ CGThing.__init__(self)
+ self.name = name
+ self.bases = bases
+ self.members = members
+ self.constructors = constructors
+ # We store our single destructor in a list, since all of our
+ # code wants lists of members.
+ self.destructors = [destructor] if destructor else []
+ self.methods = methods
+ self.typedefs = typedefs
+ self.enums = enums
+ self.unions = unions
+ self.templateArgs = templateArgs
+ self.templateSpecialization = templateSpecialization
+ self.isStruct = isStruct
+ self.disallowCopyConstruction = disallowCopyConstruction
+ self.indent = indent
+ self.defaultVisibility = 'public' if isStruct else 'private'
+ self.decorators = decorators
+ self.extradeclarations = extradeclarations
+ self.extradefinitions = extradefinitions
+
+ def getNameString(self):
+ className = self.name
+ if self.templateSpecialization:
+ className += '<%s>' % ', '.join([str(a)
+ for a in self.templateSpecialization])
+ return className
+
+ def declare(self):
+ result = ''
+ if self.templateArgs:
+ templateArgs = [a.declare() for a in self.templateArgs]
+ templateArgs = templateArgs[len(self.templateSpecialization):]
+ result += ('template <%s>\n' %
+ ','.join([str(a) for a in templateArgs]))
+
+ type = 'struct' if self.isStruct else 'class'
+
+ if self.templateSpecialization:
+ specialization = \
+ '<%s>' % ', '.join([str(a) for a in self.templateSpecialization])
+ else:
+ specialization = ''
+
+ myself = '%s %s%s' % (type, self.name, specialization)
+ if self.decorators != '':
+ myself += " " + self.decorators
+ result += myself
+
+ if self.bases:
+ inherit = ' : '
+ result += inherit
+ # Grab our first base
+ baseItems = [CGGeneric(b.declare(self)) for b in self.bases]
+ bases = baseItems[:1]
+ # Indent the rest
+ bases.extend(CGIndenter(b, len(myself) + len(inherit))
+ for b in baseItems[1:])
+ result += ",\n".join(b.define() for b in bases)
+
+ result += '\n{\n'
+
+ result += self.extradeclarations
+
+ def declareMembers(cgClass, memberList, defaultVisibility):
+ members = {'private': [], 'protected': [], 'public': []}
+
+ for member in memberList:
+ members[member.visibility].append(member)
+
+ if defaultVisibility == 'public':
+ order = ['public', 'protected', 'private']
+ else:
+ order = ['private', 'protected', 'public']
+
+ result = ''
+
+ lastVisibility = defaultVisibility
+ for visibility in order:
+ list = members[visibility]
+ if list:
+ if visibility != lastVisibility:
+ result += visibility + ':\n'
+ for member in list:
+ result += indent(member.declare(cgClass))
+ lastVisibility = visibility
+ return (result, lastVisibility)
+
+ if self.disallowCopyConstruction:
+ class DisallowedCopyConstructor(object):
+ def __init__(self):
+ self.visibility = "private"
+
+ def declare(self, cgClass):
+ name = cgClass.getNameString()
+ return ("%s(const %s&) = delete;\n"
+ "void operator=(const %s&) = delete;\n" % (name, name, name))
+
+ disallowedCopyConstructors = [DisallowedCopyConstructor()]
+ else:
+ disallowedCopyConstructors = []
+
+ order = [self.enums, self.unions,
+ self.typedefs, self.members,
+ self.constructors + disallowedCopyConstructors,
+ self.destructors, self.methods]
+
+ lastVisibility = self.defaultVisibility
+ pieces = []
+ for memberList in order:
+ code, lastVisibility = declareMembers(self, memberList, lastVisibility)
+
+ if code:
+ code = code.rstrip() + "\n" # remove extra blank lines at the end
+ pieces.append(code)
+
+ result += '\n'.join(pieces)
+ result += '};\n'
+ result = indent(result, len(self.indent))
+ return result
+
+ def define(self):
+ def defineMembers(cgClass, memberList, itemCount, separator=''):
+ result = ''
+ for member in memberList:
+ if itemCount != 0:
+ result = result + separator
+ definition = member.define(cgClass)
+ if definition:
+ # Member variables would only produce empty lines here.
+ result += definition
+ itemCount += 1
+ return (result, itemCount)
+
+ order = [(self.members, ''), (self.constructors, '\n'),
+ (self.destructors, '\n'), (self.methods, '\n')]
+
+ result = self.extradefinitions
+ itemCount = 0
+ for memberList, separator in order:
+ memberString, itemCount = defineMembers(self, memberList,
+ itemCount, separator)
+ result = result + memberString
+ return result
+
+
+class CGResolveOwnProperty(CGAbstractStaticMethod):
+ def __init__(self, descriptor):
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'wrapper'),
+ Argument('JS::Handle<JSObject*>', 'obj'),
+ Argument('JS::Handle<jsid>', 'id'),
+ Argument('JS::MutableHandle<JS::PropertyDescriptor>', 'desc'),
+ ]
+ CGAbstractStaticMethod.__init__(self, descriptor, "ResolveOwnProperty",
+ "bool", args)
+
+ def definition_body(self):
+ return "return js::GetProxyHandler(obj)->getOwnPropertyDescriptor(cx, wrapper, id, desc);\n"
+
+
+class CGResolveOwnPropertyViaResolve(CGAbstractBindingMethod):
+ """
+ An implementation of Xray ResolveOwnProperty stuff for things that have a
+ resolve hook.
+ """
+ def __init__(self, descriptor):
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'wrapper'),
+ Argument('JS::Handle<JSObject*>', 'obj'),
+ Argument('JS::Handle<jsid>', 'id'),
+ Argument('JS::MutableHandle<JS::PropertyDescriptor>', 'desc')]
+ CGAbstractBindingMethod.__init__(self, descriptor,
+ "ResolveOwnPropertyViaResolve",
+ args, getThisObj="",
+ callArgs="")
+
+ def generate_code(self):
+ return CGGeneric(dedent("""
+ {
+ // Since we're dealing with an Xray, do the resolve on the
+ // underlying object first. That gives it a chance to
+ // define properties on the actual object as needed, and
+ // then use the fact that it created the objects as a flag
+ // to avoid re-resolving the properties if someone deletes
+ // them.
+ JSAutoCompartment ac(cx, obj);
+ JS::Rooted<JS::PropertyDescriptor> objDesc(cx);
+ if (!self->DoResolve(cx, obj, id, &objDesc)) {
+ return false;
+ }
+ // If desc.value() is undefined, then the DoResolve call
+ // has already defined the property on the object. Don't
+ // try to also define it.
+ if (objDesc.object() &&
+ !objDesc.value().isUndefined() &&
+ !JS_DefinePropertyById(cx, obj, id, objDesc)) {
+ return false;
+ }
+ }
+ return self->DoResolve(cx, wrapper, id, desc);
+ """))
+
+
+class CGEnumerateOwnProperties(CGAbstractStaticMethod):
+ def __init__(self, descriptor):
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'wrapper'),
+ Argument('JS::Handle<JSObject*>', 'obj'),
+ Argument('JS::AutoIdVector&', 'props')]
+ CGAbstractStaticMethod.__init__(self, descriptor,
+ "EnumerateOwnProperties", "bool", args)
+
+ def definition_body(self):
+ return "return js::GetProxyHandler(obj)->ownPropertyKeys(cx, wrapper, props);\n"
+
+
+class CGEnumerateOwnPropertiesViaGetOwnPropertyNames(CGAbstractBindingMethod):
+ """
+ An implementation of Xray EnumerateOwnProperties stuff for things
+ that have a resolve hook.
+ """
+ def __init__(self, descriptor):
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'wrapper'),
+ Argument('JS::Handle<JSObject*>', 'obj'),
+ Argument('JS::AutoIdVector&', 'props')]
+ CGAbstractBindingMethod.__init__(self, descriptor,
+ "EnumerateOwnPropertiesViaGetOwnPropertyNames",
+ args, getThisObj="",
+ callArgs="")
+
+ def generate_code(self):
+ return CGGeneric(dedent("""
+ AutoTArray<nsString, 8> names;
+ binding_detail::FastErrorResult rv;
+ self->GetOwnPropertyNames(cx, names, rv);
+ if (rv.MaybeSetPendingException(cx)) {
+ return false;
+ }
+ // OK to pass null as "proxy" because it's ignored if
+ // shadowPrototypeProperties is true
+ return AppendNamedPropertyIds(cx, nullptr, names, true, props);
+ """))
+
+
+class CGPrototypeTraitsClass(CGClass):
+ def __init__(self, descriptor, indent=''):
+ templateArgs = [Argument('prototypes::ID', 'PrototypeID')]
+ templateSpecialization = ['prototypes::id::' + descriptor.name]
+ enums = [ClassEnum('', ['Depth'],
+ [descriptor.interface.inheritanceDepth()])]
+ CGClass.__init__(self, 'PrototypeTraits', indent=indent,
+ templateArgs=templateArgs,
+ templateSpecialization=templateSpecialization,
+ enums=enums, isStruct=True)
+
+ def deps(self):
+ return set()
+
+
+class CGClassForwardDeclare(CGThing):
+ def __init__(self, name, isStruct=False):
+ CGThing.__init__(self)
+ self.name = name
+ self.isStruct = isStruct
+
+ def declare(self):
+ type = 'struct' if self.isStruct else 'class'
+ return '%s %s;\n' % (type, self.name)
+
+ def define(self):
+ # Header only
+ return ''
+
+ def deps(self):
+ return set()
+
+
+class CGProxySpecialOperation(CGPerSignatureCall):
+ """
+ Base class for classes for calling an indexed or named special operation
+ (don't use this directly, use the derived classes below).
+
+ If checkFound is False, will just assert that the prop is found instead of
+ checking that it is before wrapping the value.
+
+ resultVar: See the docstring for CGCallGenerator.
+
+ foundVar: For getters and deleters, the generated code can also set a bool
+ variable, declared by the caller, if the given indexed or named property
+ already existed. If the caller wants this, it should pass the name of the
+ bool variable as the foundVar keyword argument to the constructor. The
+ caller is responsible for declaring the variable and initializing it to
+ false.
+ """
+ def __init__(self, descriptor, operation, checkFound=True,
+ argumentHandleValue=None, resultVar=None, foundVar=None):
+ self.checkFound = checkFound
+ self.foundVar = foundVar or "found"
+
+ nativeName = MakeNativeName(descriptor.binaryNameFor(operation))
+ operation = descriptor.operations[operation]
+ assert len(operation.signatures()) == 1
+ signature = operation.signatures()[0]
+
+ returnType, arguments = signature
+
+ # We pass len(arguments) as the final argument so that the
+ # CGPerSignatureCall won't do any argument conversion of its own.
+ CGPerSignatureCall.__init__(self, returnType, arguments, nativeName,
+ False, descriptor, operation,
+ len(arguments), resultVar=resultVar)
+
+ if operation.isSetter() or operation.isCreator():
+ # arguments[0] is the index or name of the item that we're setting.
+ argument = arguments[1]
+ info = getJSToNativeConversionInfo(
+ argument.type, descriptor,
+ treatNullAs=argument.treatNullAs,
+ sourceDescription=("value being assigned to %s setter" %
+ descriptor.interface.identifier.name))
+ if argumentHandleValue is None:
+ argumentHandleValue = "desc.value()"
+ rootedValue = fill(
+ """
+ JS::Rooted<JS::Value> rootedValue(cx, ${argumentHandleValue});
+ """,
+ argumentHandleValue = argumentHandleValue)
+ templateValues = {
+ "declName": argument.identifier.name,
+ "holderName": argument.identifier.name + "_holder",
+ "val": argumentHandleValue,
+ "maybeMutableVal": "&rootedValue",
+ "obj": "obj",
+ "passedToJSImpl": "false"
+ }
+ self.cgRoot.prepend(instantiateJSToNativeConversion(info, templateValues))
+ # rootedValue needs to come before the conversion, so we
+ # need to prepend it last.
+ self.cgRoot.prepend(CGGeneric(rootedValue))
+ elif operation.isGetter() or operation.isDeleter():
+ if foundVar is None:
+ self.cgRoot.prepend(CGGeneric("bool found = false;\n"))
+
+ def getArguments(self):
+ args = [(a, a.identifier.name) for a in self.arguments]
+ if self.idlNode.isGetter() or self.idlNode.isDeleter():
+ args.append((FakeArgument(BuiltinTypes[IDLBuiltinType.Types.boolean],
+ self.idlNode),
+ self.foundVar))
+ return args
+
+ def wrap_return_value(self):
+ if not self.idlNode.isGetter() or self.templateValues is None:
+ return ""
+
+ wrap = CGGeneric(wrapForType(self.returnType, self.descriptor, self.templateValues))
+ if self.checkFound:
+ wrap = CGIfWrapper(wrap, self.foundVar)
+ else:
+ wrap = CGList([CGGeneric("MOZ_ASSERT(" + self.foundVar + ");\n"), wrap])
+ return "\n" + wrap.define()
+
+
+class CGProxyIndexedOperation(CGProxySpecialOperation):
+ """
+ Class to generate a call to an indexed operation.
+
+ If doUnwrap is False, the caller is responsible for making sure a variable
+ named 'self' holds the C++ object somewhere where the code we generate
+ will see it.
+
+ If checkFound is False, will just assert that the prop is found instead of
+ checking that it is before wrapping the value.
+
+ resultVar: See the docstring for CGCallGenerator.
+
+ foundVar: See the docstring for CGProxySpecialOperation.
+ """
+ def __init__(self, descriptor, name, doUnwrap=True, checkFound=True,
+ argumentHandleValue=None, resultVar=None, foundVar=None):
+ self.doUnwrap = doUnwrap
+ CGProxySpecialOperation.__init__(self, descriptor, name, checkFound,
+ argumentHandleValue=argumentHandleValue,
+ resultVar=resultVar,
+ foundVar=foundVar)
+
+ def define(self):
+ # Our first argument is the id we're getting.
+ argName = self.arguments[0].identifier.name
+ if argName == "index":
+ # We already have our index in a variable with that name
+ setIndex = ""
+ else:
+ setIndex = "uint32_t %s = index;\n" % argName
+ if self.doUnwrap:
+ unwrap = "%s* self = UnwrapProxy(proxy);\n" % self.descriptor.nativeType
+ else:
+ unwrap = ""
+ return (setIndex + unwrap +
+ CGProxySpecialOperation.define(self))
+
+
+class CGProxyIndexedGetter(CGProxyIndexedOperation):
+ """
+ Class to generate a call to an indexed getter. If templateValues is not None
+ the returned value will be wrapped with wrapForType using templateValues.
+
+ If doUnwrap is False, the caller is responsible for making sure a variable
+ named 'self' holds the C++ object somewhere where the code we generate
+ will see it.
+
+ If checkFound is False, will just assert that the prop is found instead of
+ checking that it is before wrapping the value.
+
+ foundVar: See the docstring for CGProxySpecialOperation.
+ """
+ def __init__(self, descriptor, templateValues=None, doUnwrap=True,
+ checkFound=True, foundVar=None):
+ self.templateValues = templateValues
+ CGProxyIndexedOperation.__init__(self, descriptor, 'IndexedGetter',
+ doUnwrap, checkFound, foundVar=foundVar)
+
+
+class CGProxyIndexedPresenceChecker(CGProxyIndexedGetter):
+ """
+ Class to generate a call that checks whether an indexed property exists.
+
+ For now, we just delegate to CGProxyIndexedGetter
+
+ foundVar: See the docstring for CGProxySpecialOperation.
+ """
+ def __init__(self, descriptor, foundVar):
+ CGProxyIndexedGetter.__init__(self, descriptor, foundVar=foundVar)
+ self.cgRoot.append(CGGeneric("(void)result;\n"))
+
+
+class CGProxyIndexedSetter(CGProxyIndexedOperation):
+ """
+ Class to generate a call to an indexed setter.
+ """
+ def __init__(self, descriptor, argumentHandleValue=None):
+ CGProxyIndexedOperation.__init__(self, descriptor, 'IndexedSetter',
+ argumentHandleValue=argumentHandleValue)
+
+
+class CGProxyNamedOperation(CGProxySpecialOperation):
+ """
+ Class to generate a call to a named operation.
+
+ 'value' is the jsval to use for the name; None indicates that it should be
+ gotten from the property id.
+
+ resultVar: See the docstring for CGCallGenerator.
+
+ foundVar: See the docstring for CGProxySpecialOperation.
+ """
+ def __init__(self, descriptor, name, value=None, argumentHandleValue=None,
+ resultVar=None, foundVar=None):
+ CGProxySpecialOperation.__init__(self, descriptor, name,
+ argumentHandleValue=argumentHandleValue,
+ resultVar=resultVar,
+ foundVar=foundVar)
+ self.value = value
+
+ def define(self):
+ # Our first argument is the id we're getting.
+ argName = self.arguments[0].identifier.name
+ if argName == "id":
+ # deal with the name collision
+ decls = "JS::Rooted<jsid> id_(cx, id);\n"
+ idName = "id_"
+ else:
+ decls = ""
+ idName = "id"
+
+ decls += "binding_detail::FakeString %s;\n" % argName
+
+ main = fill(
+ """
+ ${nativeType}* self = UnwrapProxy(proxy);
+ $*{op}
+ """,
+ nativeType=self.descriptor.nativeType,
+ op=CGProxySpecialOperation.define(self))
+
+ if self.value is None:
+ return fill(
+ """
+ $*{decls}
+ bool isSymbol;
+ if (!ConvertIdToString(cx, ${idName}, ${argName}, isSymbol)) {
+ return false;
+ }
+ if (!isSymbol) {
+ $*{main}
+ }
+ """,
+ decls=decls,
+ idName=idName,
+ argName=argName,
+ main=main)
+
+ # Sadly, we have to set up nameVal even if we have an atom id,
+ # because we don't know for sure, and we can end up needing it
+ # so it needs to be higher up the stack. Using a Maybe here
+ # seems like probable overkill.
+ return fill(
+ """
+ $*{decls}
+ JS::Rooted<JS::Value> nameVal(cx, ${value});
+ if (!nameVal.isSymbol()) {
+ if (!ConvertJSValueToString(cx, nameVal, eStringify, eStringify,
+ ${argName})) {
+ return false;
+ }
+ $*{main}
+ }
+ """,
+ decls=decls,
+ value=self.value,
+ argName=argName,
+ main=main)
+
+
+class CGProxyNamedGetter(CGProxyNamedOperation):
+ """
+ Class to generate a call to an named getter. If templateValues is not None
+ the returned value will be wrapped with wrapForType using templateValues.
+ 'value' is the jsval to use for the name; None indicates that it should be
+ gotten from the property id.
+
+ foundVar: See the docstring for CGProxySpecialOperation.
+ """
+ def __init__(self, descriptor, templateValues=None, value=None,
+ foundVar=None):
+ self.templateValues = templateValues
+ CGProxyNamedOperation.__init__(self, descriptor, 'NamedGetter', value,
+ foundVar=foundVar)
+
+
+class CGProxyNamedPresenceChecker(CGProxyNamedGetter):
+ """
+ Class to generate a call that checks whether a named property exists.
+
+ For now, we just delegate to CGProxyNamedGetter
+
+ foundVar: See the docstring for CGProxySpecialOperation.
+ """
+ def __init__(self, descriptor, foundVar=None):
+ CGProxyNamedGetter.__init__(self, descriptor, foundVar=foundVar)
+ self.cgRoot.append(CGGeneric("(void)result;\n"))
+
+
+class CGProxyNamedSetter(CGProxyNamedOperation):
+ """
+ Class to generate a call to a named setter.
+ """
+ def __init__(self, descriptor, argumentHandleValue=None):
+ CGProxyNamedOperation.__init__(self, descriptor, 'NamedSetter',
+ argumentHandleValue=argumentHandleValue)
+
+
+class CGProxyNamedDeleter(CGProxyNamedOperation):
+ """
+ Class to generate a call to a named deleter.
+
+ resultVar: See the docstring for CGCallGenerator.
+
+ foundVar: See the docstring for CGProxySpecialOperation.
+ """
+ def __init__(self, descriptor, resultVar=None, foundVar=None):
+ CGProxyNamedOperation.__init__(self, descriptor, 'NamedDeleter',
+ resultVar=resultVar,
+ foundVar=foundVar)
+
+
+class CGProxyIsProxy(CGAbstractMethod):
+ def __init__(self, descriptor):
+ args = [Argument('JSObject*', 'obj')]
+ CGAbstractMethod.__init__(self, descriptor, "IsProxy", "bool", args, alwaysInline=True)
+
+ def declare(self):
+ return ""
+
+ def definition_body(self):
+ return "return js::IsProxy(obj) && js::GetProxyHandler(obj) == DOMProxyHandler::getInstance();\n"
+
+
+class CGProxyUnwrap(CGAbstractMethod):
+ def __init__(self, descriptor):
+ args = [Argument('JSObject*', 'obj')]
+ CGAbstractMethod.__init__(self, descriptor, "UnwrapProxy", descriptor.nativeType + '*', args, alwaysInline=True)
+
+ def declare(self):
+ return ""
+
+ def definition_body(self):
+ return fill(
+ """
+ MOZ_ASSERT(js::IsProxy(obj));
+ if (js::GetProxyHandler(obj) != DOMProxyHandler::getInstance()) {
+ MOZ_ASSERT(xpc::WrapperFactory::IsXrayWrapper(obj));
+ obj = js::UncheckedUnwrap(obj);
+ }
+ MOZ_ASSERT(IsProxy(obj));
+ return static_cast<${type}*>(js::GetProxyPrivate(obj).toPrivate());
+ """,
+ type=self.descriptor.nativeType)
+
+
+class CGDOMJSProxyHandler_getOwnPropDescriptor(ClassMethod):
+ def __init__(self, descriptor):
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'proxy'),
+ Argument('JS::Handle<jsid>', 'id'),
+ Argument('bool', 'ignoreNamedProps'),
+ Argument('JS::MutableHandle<JS::PropertyDescriptor>', 'desc')]
+ ClassMethod.__init__(self, "getOwnPropDescriptor", "bool", args,
+ virtual=True, override=True, const=True)
+ self.descriptor = descriptor
+
+ def getBody(self):
+ indexedGetter = self.descriptor.operations['IndexedGetter']
+ indexedSetter = self.descriptor.operations['IndexedSetter']
+
+ if self.descriptor.supportsIndexedProperties():
+ readonly = toStringBool(indexedSetter is None)
+ fillDescriptor = "FillPropertyDescriptor(desc, proxy, %s);\nreturn true;\n" % readonly
+ templateValues = {
+ 'jsvalRef': 'desc.value()',
+ 'jsvalHandle': 'desc.value()',
+ 'obj': 'proxy',
+ 'successCode': fillDescriptor
+ }
+ getIndexed = fill(
+ """
+ uint32_t index = GetArrayIndexFromId(cx, id);
+ if (IsArrayIndex(index)) {
+ $*{callGetter}
+ }
+
+ """,
+ callGetter=CGProxyIndexedGetter(self.descriptor, templateValues).define())
+ else:
+ getIndexed = ""
+
+ if self.descriptor.supportsNamedProperties():
+ operations = self.descriptor.operations
+ readonly = toStringBool(operations['NamedSetter'] is None)
+ fillDescriptor = (
+ "FillPropertyDescriptor(desc, proxy, %s, %s);\n"
+ "return true;\n" %
+ (readonly,
+ toStringBool(self.descriptor.namedPropertiesEnumerable)))
+ templateValues = {'jsvalRef': 'desc.value()', 'jsvalHandle': 'desc.value()',
+ 'obj': 'proxy', 'successCode': fillDescriptor}
+
+ computeCondition = dedent("""
+ bool hasOnProto;
+ if (!HasPropertyOnPrototype(cx, proxy, id, &hasOnProto)) {
+ return false;
+ }
+ callNamedGetter = !hasOnProto;
+ """)
+ if self.descriptor.interface.getExtendedAttribute('OverrideBuiltins'):
+ computeCondition = fill(
+ """
+ if (!isXray) {
+ callNamedGetter = true;
+ } else {
+ $*{hasOnProto}
+ }
+ """,
+ hasOnProto=computeCondition)
+
+ outerCondition = "!ignoreNamedProps"
+ if self.descriptor.supportsIndexedProperties():
+ outerCondition = "!IsArrayIndex(index) && " + outerCondition
+
+ namedGetCode = CGProxyNamedGetter(self.descriptor,
+ templateValues).define()
+ namedGet = fill("""
+ bool callNamedGetter = false;
+ if (${outerCondition}) {
+ $*{computeCondition}
+ }
+ if (callNamedGetter) {
+ $*{namedGetCode}
+ }
+ """,
+ outerCondition=outerCondition,
+ computeCondition=computeCondition,
+ namedGetCode=namedGetCode)
+ namedGet += "\n"
+ else:
+ namedGet = ""
+
+ return fill(
+ """
+ bool isXray = xpc::WrapperFactory::IsXrayWrapper(proxy);
+ $*{getIndexed}
+ JS::Rooted<JSObject*> expando(cx);
+ if (!isXray && (expando = GetExpandoObject(proxy))) {
+ if (!JS_GetOwnPropertyDescriptorById(cx, expando, id, desc)) {
+ return false;
+ }
+ if (desc.object()) {
+ // Pretend the property lives on the wrapper.
+ desc.object().set(proxy);
+ return true;
+ }
+ }
+
+ $*{namedGet}
+ desc.object().set(nullptr);
+ return true;
+ """,
+ getIndexed=getIndexed,
+ namedGet=namedGet)
+
+
+class CGDOMJSProxyHandler_defineProperty(ClassMethod):
+ def __init__(self, descriptor):
+ # The usual convention is to name the ObjectOpResult out-parameter
+ # `result`, but that name is a bit overloaded around here.
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'proxy'),
+ Argument('JS::Handle<jsid>', 'id'),
+ Argument('JS::Handle<JS::PropertyDescriptor>', 'desc'),
+ Argument('JS::ObjectOpResult&', 'opresult'),
+ Argument('bool*', 'defined')]
+ ClassMethod.__init__(self, "defineProperty", "bool", args, virtual=True, override=True, const=True)
+ self.descriptor = descriptor
+
+ def getBody(self):
+ set = ""
+
+ indexedSetter = self.descriptor.operations['IndexedSetter']
+ if indexedSetter:
+ if self.descriptor.operations['IndexedCreator'] is not indexedSetter:
+ raise TypeError("Can't handle creator that's different from the setter")
+ set += fill(
+ """
+ uint32_t index = GetArrayIndexFromId(cx, id);
+ if (IsArrayIndex(index)) {
+ *defined = true;
+ $*{callSetter}
+ return opresult.succeed();
+ }
+ """,
+ callSetter=CGProxyIndexedSetter(self.descriptor).define())
+ elif self.descriptor.supportsIndexedProperties():
+ # We allow untrusted content to prevent Xrays from setting a
+ # property if that property is an indexed property and we have no
+ # indexed setter. That's how the object would normally behave if
+ # you tried to set the property on it. That means we don't need to
+ # do anything special for Xrays here.
+ set += dedent(
+ """
+ if (IsArrayIndex(GetArrayIndexFromId(cx, id))) {
+ *defined = true;
+ return opresult.failNoIndexedSetter();
+ }
+ """)
+
+ namedSetter = self.descriptor.operations['NamedSetter']
+ if namedSetter:
+ if self.descriptor.hasUnforgeableMembers:
+ raise TypeError("Can't handle a named setter on an interface "
+ "that has unforgeables. Figure out how that "
+ "should work!")
+ if self.descriptor.operations['NamedCreator'] is not namedSetter:
+ raise TypeError("Can't handle creator that's different from the setter")
+ # If we support indexed properties, we won't get down here for
+ # indices, so we can just do our setter unconditionally here.
+ set += fill(
+ """
+ *defined = true;
+ $*{callSetter}
+
+ return opresult.succeed();
+ """,
+ callSetter=CGProxyNamedSetter(self.descriptor).define())
+ else:
+ # We allow untrusted content to prevent Xrays from setting a
+ # property if that property is already a named property on the
+ # object and we have no named setter. That's how the object would
+ # normally behave if you tried to set the property on it. That
+ # means we don't need to do anything special for Xrays here.
+ if self.descriptor.supportsNamedProperties():
+ set += fill(
+ """
+ bool found = false;
+ $*{presenceChecker}
+
+ if (found) {
+ *defined = true;
+ return opresult.failNoNamedSetter();
+ }
+ """,
+ presenceChecker=CGProxyNamedPresenceChecker(self.descriptor, foundVar="found").define())
+ set += ("return mozilla::dom::DOMProxyHandler::defineProperty(%s);\n" %
+ ", ".join(a.name for a in self.args))
+ return set
+
+
+def getDeleterBody(descriptor, type, foundVar=None):
+ """
+ type should be "Named" or "Indexed"
+
+ The possible outcomes:
+ - an error happened (the emitted code returns false)
+ - own property not found (foundVar=false, deleteSucceeded=true)
+ - own property found and deleted (foundVar=true, deleteSucceeded=true)
+ - own property found but can't be deleted (foundVar=true, deleteSucceeded=false)
+ """
+ assert type in ("Named", "Indexed")
+ deleter = descriptor.operations[type + 'Deleter']
+ if deleter:
+ assert type == "Named"
+ assert foundVar is not None
+ if descriptor.hasUnforgeableMembers:
+ raise TypeError("Can't handle a deleter on an interface "
+ "that has unforgeables. Figure out how "
+ "that should work!")
+ # See if the deleter method is fallible.
+ t = deleter.signatures()[0][0]
+ if t.isPrimitive() and not t.nullable() and t.tag() == IDLType.Tags.bool:
+ # The deleter method has a boolean return value. When a
+ # property is found, the return value indicates whether it
+ # was successfully deleted.
+ setDS = fill(
+ """
+ if (!${foundVar}) {
+ deleteSucceeded = true;
+ }
+ """,
+ foundVar=foundVar)
+ else:
+ # No boolean return value: if a property is found,
+ # deleting it always succeeds.
+ setDS = "deleteSucceeded = true;\n"
+
+ body = (CGProxyNamedDeleter(descriptor,
+ resultVar="deleteSucceeded",
+ foundVar=foundVar).define() +
+ setDS)
+ elif getattr(descriptor, "supports%sProperties" % type)():
+ presenceCheckerClass = globals()["CGProxy%sPresenceChecker" % type]
+ foundDecl = ""
+ if foundVar is None:
+ foundVar = "found"
+ foundDecl = "bool found = false;\n"
+ body = fill(
+ """
+ $*{foundDecl}
+ $*{presenceChecker}
+ deleteSucceeded = !${foundVar};
+ """,
+ foundDecl=foundDecl,
+ presenceChecker=presenceCheckerClass(descriptor, foundVar=foundVar).define(),
+ foundVar=foundVar)
+ else:
+ body = None
+ return body
+
+
+class CGDeleteNamedProperty(CGAbstractStaticMethod):
+ def __init__(self, descriptor):
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'xray'),
+ Argument('JS::Handle<JSObject*>', 'proxy'),
+ Argument('JS::Handle<jsid>', 'id'),
+ Argument('JS::ObjectOpResult&', 'opresult')]
+ CGAbstractStaticMethod.__init__(self, descriptor, "DeleteNamedProperty",
+ "bool", args)
+
+ def definition_body(self):
+ return fill(
+ """
+ MOZ_ASSERT(xpc::WrapperFactory::IsXrayWrapper(xray));
+ MOZ_ASSERT(js::IsProxy(proxy));
+ MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(proxy));
+ JSAutoCompartment ac(cx, proxy);
+ bool deleteSucceeded;
+ bool found = false;
+ $*{namedBody}
+ if (!found || deleteSucceeded) {
+ return opresult.succeed();
+ }
+ return opresult.failCantDelete();
+ """,
+ namedBody=getDeleterBody(self.descriptor, "Named", foundVar="found"))
+
+
+class CGDOMJSProxyHandler_delete(ClassMethod):
+ def __init__(self, descriptor):
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'proxy'),
+ Argument('JS::Handle<jsid>', 'id'),
+ Argument('JS::ObjectOpResult&', 'opresult')]
+ ClassMethod.__init__(self, "delete_", "bool", args,
+ virtual=True, override=True, const=True)
+ self.descriptor = descriptor
+
+ def getBody(self):
+ delete = dedent("""
+ MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(proxy),
+ "Should not have a XrayWrapper here");
+
+ """)
+
+ indexedBody = getDeleterBody(self.descriptor, "Indexed")
+ if indexedBody is not None:
+ delete += fill(
+ """
+ uint32_t index = GetArrayIndexFromId(cx, id);
+ if (IsArrayIndex(index)) {
+ bool deleteSucceeded;
+ $*{indexedBody}
+ return deleteSucceeded ? opresult.succeed() : opresult.failCantDelete();
+ }
+ """,
+ indexedBody=indexedBody)
+
+ namedBody = getDeleterBody(self.descriptor, "Named", foundVar="found")
+ if namedBody is not None:
+ delete += dedent(
+ """
+ // Try named delete only if the named property visibility
+ // algorithm says the property is visible.
+ bool tryNamedDelete = true;
+ { // Scope for expando
+ JS::Rooted<JSObject*> expando(cx, DOMProxyHandler::GetExpandoObject(proxy));
+ if (expando) {
+ bool hasProp;
+ if (!JS_HasPropertyById(cx, expando, id, &hasProp)) {
+ return false;
+ }
+ tryNamedDelete = !hasProp;
+ }
+ }
+ """)
+
+ if not self.descriptor.interface.getExtendedAttribute('OverrideBuiltins'):
+ delete += dedent(
+ """
+ if (tryNamedDelete) {
+ bool hasOnProto;
+ if (!HasPropertyOnPrototype(cx, proxy, id, &hasOnProto)) {
+ return false;
+ }
+ tryNamedDelete = !hasOnProto;
+ }
+ """)
+
+ # We always return above for an index id in the case when we support
+ # indexed properties, so we can just treat the id as a name
+ # unconditionally here.
+ delete += fill(
+ """
+ if (tryNamedDelete) {
+ bool found = false;
+ bool deleteSucceeded;
+ $*{namedBody}
+ if (found) {
+ return deleteSucceeded ? opresult.succeed() : opresult.failCantDelete();
+ }
+ }
+ """,
+ namedBody=namedBody)
+
+ delete += dedent("""
+
+ return dom::DOMProxyHandler::delete_(cx, proxy, id, opresult);
+ """)
+
+ return delete
+
+
+class CGDOMJSProxyHandler_ownPropNames(ClassMethod):
+ def __init__(self, descriptor, ):
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'proxy'),
+ Argument('unsigned', 'flags'),
+ Argument('JS::AutoIdVector&', 'props')]
+ ClassMethod.__init__(self, "ownPropNames", "bool", args,
+ virtual=True, override=True, const=True)
+ self.descriptor = descriptor
+
+ def getBody(self):
+ # Per spec, we do indices, then named props, then everything else
+ if self.descriptor.supportsIndexedProperties():
+ addIndices = dedent("""
+
+ uint32_t length = UnwrapProxy(proxy)->Length();
+ MOZ_ASSERT(int32_t(length) >= 0);
+ for (int32_t i = 0; i < int32_t(length); ++i) {
+ if (!props.append(INT_TO_JSID(i))) {
+ return false;
+ }
+ }
+ """)
+ else:
+ addIndices = ""
+
+ if self.descriptor.supportsNamedProperties():
+ if self.descriptor.interface.getExtendedAttribute('OverrideBuiltins'):
+ shadow = "!isXray"
+ else:
+ shadow = "false"
+ addNames = fill(
+ """
+ nsTArray<nsString> names;
+ UnwrapProxy(proxy)->GetSupportedNames(names);
+ if (!AppendNamedPropertyIds(cx, proxy, names, ${shadow}, props)) {
+ return false;
+ }
+ """,
+ shadow=shadow)
+ if not self.descriptor.namedPropertiesEnumerable:
+ addNames = CGIfWrapper(CGGeneric(addNames),
+ "flags & JSITER_HIDDEN").define()
+ addNames = "\n" + addNames
+ else:
+ addNames = ""
+
+ return fill(
+ """
+ bool isXray = xpc::WrapperFactory::IsXrayWrapper(proxy);
+ $*{addIndices}
+ $*{addNames}
+
+ JS::Rooted<JSObject*> expando(cx);
+ if (!isXray && (expando = DOMProxyHandler::GetExpandoObject(proxy)) &&
+ !js::GetPropertyKeys(cx, expando, flags, &props)) {
+ return false;
+ }
+
+ return true;
+ """,
+ addIndices=addIndices,
+ addNames=addNames)
+
+
+class CGDOMJSProxyHandler_hasOwn(ClassMethod):
+ def __init__(self, descriptor):
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'proxy'),
+ Argument('JS::Handle<jsid>', 'id'),
+ Argument('bool*', 'bp')]
+ ClassMethod.__init__(self, "hasOwn", "bool", args,
+ virtual=True, override=True, const=True)
+ self.descriptor = descriptor
+
+ def getBody(self):
+ if self.descriptor.supportsIndexedProperties():
+ indexed = fill(
+ """
+ uint32_t index = GetArrayIndexFromId(cx, id);
+ if (IsArrayIndex(index)) {
+ bool found = false;
+ $*{presenceChecker}
+
+ *bp = found;
+ return true;
+ }
+
+ """,
+ presenceChecker=CGProxyIndexedPresenceChecker(self.descriptor, foundVar="found").define())
+ else:
+ indexed = ""
+
+ if self.descriptor.supportsNamedProperties():
+ # If we support indexed properties we always return above for index
+ # property names, so no need to check for those here.
+ named = fill(
+ """
+ bool found = false;
+ $*{presenceChecker}
+
+ *bp = found;
+ """,
+ presenceChecker=CGProxyNamedPresenceChecker(self.descriptor, foundVar="found").define())
+ if not self.descriptor.interface.getExtendedAttribute('OverrideBuiltins'):
+ named = fill(
+ """
+ bool hasOnProto;
+ if (!HasPropertyOnPrototype(cx, proxy, id, &hasOnProto)) {
+ return false;
+ }
+ if (!hasOnProto) {
+ $*{protoLacksProperty}
+ return true;
+ }
+ """,
+ protoLacksProperty=named)
+ named += "*bp = false;\n"
+ else:
+ named += "\n"
+ else:
+ named = "*bp = false;\n"
+
+ return fill(
+ """
+ MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(proxy),
+ "Should not have a XrayWrapper here");
+
+ $*{indexed}
+
+ JS::Rooted<JSObject*> expando(cx, GetExpandoObject(proxy));
+ if (expando) {
+ bool b = true;
+ bool ok = JS_HasPropertyById(cx, expando, id, &b);
+ *bp = !!b;
+ if (!ok || *bp) {
+ return ok;
+ }
+ }
+
+ $*{named}
+ return true;
+ """,
+ indexed=indexed,
+ named=named)
+
+
+class CGDOMJSProxyHandler_get(ClassMethod):
+ def __init__(self, descriptor):
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'proxy'),
+ Argument('JS::Handle<JS::Value>', 'receiver'),
+ Argument('JS::Handle<jsid>', 'id'),
+ Argument('JS::MutableHandle<JS::Value>', 'vp')]
+ ClassMethod.__init__(self, "get", "bool", args,
+ virtual=True, override=True, const=True)
+ self.descriptor = descriptor
+
+ def getBody(self):
+ getUnforgeableOrExpando = dedent("""
+ { // Scope for expando
+ JS::Rooted<JSObject*> expando(cx, DOMProxyHandler::GetExpandoObject(proxy));
+ if (expando) {
+ bool hasProp;
+ if (!JS_HasPropertyById(cx, expando, id, &hasProp)) {
+ return false;
+ }
+
+ if (hasProp) {
+ // Forward the get to the expando object, but our receiver is whatever our
+ // receiver is.
+ return JS_ForwardGetPropertyTo(cx, expando, id, receiver, vp);
+ }
+ }
+ }
+ """)
+
+ templateValues = {'jsvalRef': 'vp', 'jsvalHandle': 'vp', 'obj': 'proxy'}
+
+ if self.descriptor.supportsIndexedProperties():
+ getIndexedOrExpando = fill(
+ """
+ uint32_t index = GetArrayIndexFromId(cx, id);
+ if (IsArrayIndex(index)) {
+ $*{callGetter}
+ // Even if we don't have this index, we don't forward the
+ // get on to our expando object.
+ } else {
+ $*{getUnforgeableOrExpando}
+ }
+ """,
+ callGetter=CGProxyIndexedGetter(self.descriptor, templateValues).define(),
+ getUnforgeableOrExpando=getUnforgeableOrExpando)
+ else:
+ getIndexedOrExpando = getUnforgeableOrExpando
+
+ if self.descriptor.supportsNamedProperties():
+ getNamed = CGProxyNamedGetter(self.descriptor, templateValues)
+ if self.descriptor.supportsIndexedProperties():
+ getNamed = CGIfWrapper(getNamed, "!IsArrayIndex(index)")
+ getNamed = getNamed.define() + "\n"
+ else:
+ getNamed = ""
+
+ getOnPrototype = dedent("""
+ bool foundOnPrototype;
+ if (!GetPropertyOnPrototype(cx, proxy, receiver, id, &foundOnPrototype, vp)) {
+ return false;
+ }
+
+ if (foundOnPrototype) {
+ return true;
+ }
+
+ """)
+ if self.descriptor.interface.getExtendedAttribute('OverrideBuiltins'):
+ getNamed = getNamed + getOnPrototype
+ else:
+ getNamed = getOnPrototype + getNamed
+
+ return fill(
+ """
+ MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(proxy),
+ "Should not have a XrayWrapper here");
+
+ $*{indexedOrExpando}
+
+ $*{named}
+ vp.setUndefined();
+ return true;
+ """,
+ indexedOrExpando=getIndexedOrExpando,
+ named=getNamed)
+
+
+class CGDOMJSProxyHandler_setCustom(ClassMethod):
+ def __init__(self, descriptor):
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'proxy'),
+ Argument('JS::Handle<jsid>', 'id'),
+ Argument('JS::Handle<JS::Value>', 'v'),
+ Argument('bool*', 'done')]
+ ClassMethod.__init__(self, "setCustom", "bool", args, virtual=True, override=True, const=True)
+ self.descriptor = descriptor
+
+ def getBody(self):
+ assertion = ("MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(proxy),\n"
+ ' "Should not have a XrayWrapper here");\n')
+
+ # Correctness first. If we have a NamedSetter and [OverrideBuiltins],
+ # always call the NamedSetter and never do anything else.
+ namedSetter = self.descriptor.operations['NamedSetter']
+ if (namedSetter is not None and
+ self.descriptor.interface.getExtendedAttribute('OverrideBuiltins')):
+ # Check assumptions.
+ if self.descriptor.supportsIndexedProperties():
+ raise ValueError("In interface " + self.descriptor.name + ": " +
+ "Can't cope with [OverrideBuiltins] and an indexed getter")
+ if self.descriptor.operations['NamedCreator'] is not namedSetter:
+ raise ValueError("In interface " + self.descriptor.name + ": " +
+ "Can't cope with named setter that is not also a named creator")
+ if self.descriptor.hasUnforgeableMembers:
+ raise ValueError("In interface " + self.descriptor.name + ": " +
+ "Can't cope with [OverrideBuiltins] and unforgeable members")
+
+ callSetter = CGProxyNamedSetter(self.descriptor, argumentHandleValue="v")
+ return (assertion +
+ callSetter.define() +
+ "*done = true;\n"
+ "return true;\n")
+
+ # As an optimization, if we are going to call an IndexedSetter, go
+ # ahead and call it and have done.
+ indexedSetter = self.descriptor.operations['IndexedSetter']
+ if indexedSetter is not None:
+ if self.descriptor.operations['IndexedCreator'] is not indexedSetter:
+ raise ValueError("In interface " + self.descriptor.name + ": " +
+ "Can't cope with indexed setter that is not " +
+ "also an indexed creator")
+ setIndexed = fill(
+ """
+ uint32_t index = GetArrayIndexFromId(cx, id);
+ if (IsArrayIndex(index)) {
+ $*{callSetter}
+ *done = true;
+ return true;
+ }
+
+ """,
+ callSetter=CGProxyIndexedSetter(self.descriptor,
+ argumentHandleValue="v").define())
+ else:
+ setIndexed = ""
+
+ return (assertion +
+ setIndexed +
+ "*done = false;\n"
+ "return true;\n")
+
+
+class CGDOMJSProxyHandler_className(ClassMethod):
+ def __init__(self, descriptor):
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'proxy')]
+ ClassMethod.__init__(self, "className", "const char*", args,
+ virtual=True, override=True, const=True)
+ self.descriptor = descriptor
+
+ def getBody(self):
+ return 'return "%s";\n' % self.descriptor.name
+
+
+class CGDOMJSProxyHandler_finalizeInBackground(ClassMethod):
+ def __init__(self, descriptor):
+ args = [Argument('const JS::Value&', 'priv')]
+ ClassMethod.__init__(self, "finalizeInBackground", "bool", args,
+ virtual=True, override=True, const=True)
+ self.descriptor = descriptor
+
+ def getBody(self):
+ return "return false;\n"
+
+
+class CGDOMJSProxyHandler_finalize(ClassMethod):
+ def __init__(self, descriptor):
+ args = [Argument('JSFreeOp*', 'fop'), Argument('JSObject*', 'proxy')]
+ ClassMethod.__init__(self, "finalize", "void", args,
+ virtual=True, override=True, const=True)
+ self.descriptor = descriptor
+
+ def getBody(self):
+ return (("%s* self = UnwrapPossiblyNotInitializedDOMObject<%s>(proxy);\n" %
+ (self.descriptor.nativeType, self.descriptor.nativeType)) +
+ finalizeHook(self.descriptor, FINALIZE_HOOK_NAME, self.args[0].name).define())
+
+
+class CGDOMJSProxyHandler_getElements(ClassMethod):
+ def __init__(self, descriptor):
+ assert descriptor.supportsIndexedProperties()
+
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'proxy'),
+ Argument('uint32_t', 'begin'),
+ Argument('uint32_t', 'end'),
+ Argument('js::ElementAdder*', 'adder')]
+ ClassMethod.__init__(self, "getElements", "bool", args, virtual=True, override=True, const=True)
+ self.descriptor = descriptor
+
+ def getBody(self):
+ # Just like ownPropertyKeys we'll assume that we have no holes, so
+ # we have all properties from 0 to length. If that ever changes
+ # (unlikely), we'll need to do something a bit more clever with how we
+ # forward on to our ancestor.
+
+ templateValues = {
+ 'jsvalRef': 'temp',
+ 'jsvalHandle': '&temp',
+ 'obj': 'proxy',
+ 'successCode': ("if (!adder->append(cx, temp)) return false;\n"
+ "continue;\n")
+ }
+ get = CGProxyIndexedGetter(self.descriptor, templateValues, False, False).define()
+
+ return fill(
+ """
+ JS::Rooted<JS::Value> temp(cx);
+ MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(proxy),
+ "Should not have a XrayWrapper here");
+
+ ${nativeType}* self = UnwrapProxy(proxy);
+ uint32_t length = self->Length();
+ // Compute the end of the indices we'll get ourselves
+ uint32_t ourEnd = std::max(begin, std::min(end, length));
+
+ for (uint32_t index = begin; index < ourEnd; ++index) {
+ $*{get}
+ }
+
+ if (end > ourEnd) {
+ JS::Rooted<JSObject*> proto(cx);
+ if (!js::GetObjectProto(cx, proxy, &proto)) {
+ return false;
+ }
+ return js::GetElementsWithAdder(cx, proto, proxy, ourEnd, end, adder);
+ }
+
+ return true;
+ """,
+ nativeType=self.descriptor.nativeType,
+ get=get)
+
+
+class CGDOMJSProxyHandler_getInstance(ClassMethod):
+ def __init__(self):
+ ClassMethod.__init__(self, "getInstance", "const DOMProxyHandler*", [], static=True)
+
+ def getBody(self):
+ return dedent("""
+ static const DOMProxyHandler instance;
+ return &instance;
+ """)
+
+
+class CGDOMJSProxyHandler_getPrototypeIfOrdinary(ClassMethod):
+ def __init__(self):
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'proxy'),
+ Argument('bool*', 'isOrdinary'),
+ Argument('JS::MutableHandle<JSObject*>', 'proto')]
+
+ ClassMethod.__init__(self, "getPrototypeIfOrdinary", "bool", args,
+ virtual=True, override=True, const=True)
+
+ def getBody(self):
+ return dedent("""
+ *isOrdinary = false;
+ return true;
+ """)
+
+
+class CGDOMJSProxyHandler_call(ClassMethod):
+ def __init__(self):
+ args = [Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JSObject*>', 'proxy'),
+ Argument('const JS::CallArgs&', 'args')]
+
+ ClassMethod.__init__(self, "call", "bool", args, virtual=True, override=True, const=True)
+
+ def getBody(self):
+ return fill(
+ """
+ return js::ForwardToNative(cx, ${legacyCaller}, args);
+ """,
+ legacyCaller=LEGACYCALLER_HOOK_NAME)
+
+
+class CGDOMJSProxyHandler_isCallable(ClassMethod):
+ def __init__(self):
+ ClassMethod.__init__(self, "isCallable", "bool",
+ [Argument('JSObject*', 'obj')],
+ virtual=True, override=True, const=True)
+
+ def getBody(self):
+ return dedent("""
+ return true;
+ """)
+
+
+class CGDOMJSProxyHandler(CGClass):
+ def __init__(self, descriptor):
+ assert (descriptor.supportsIndexedProperties() or
+ descriptor.supportsNamedProperties() or
+ descriptor.hasNonOrdinaryGetPrototypeOf())
+ methods = [CGDOMJSProxyHandler_getOwnPropDescriptor(descriptor),
+ CGDOMJSProxyHandler_defineProperty(descriptor),
+ ClassUsingDeclaration("mozilla::dom::DOMProxyHandler",
+ "defineProperty"),
+ CGDOMJSProxyHandler_ownPropNames(descriptor),
+ CGDOMJSProxyHandler_hasOwn(descriptor),
+ CGDOMJSProxyHandler_get(descriptor),
+ CGDOMJSProxyHandler_className(descriptor),
+ CGDOMJSProxyHandler_finalizeInBackground(descriptor),
+ CGDOMJSProxyHandler_finalize(descriptor),
+ CGDOMJSProxyHandler_getInstance(),
+ CGDOMJSProxyHandler_delete(descriptor)]
+ constructors = [
+ ClassConstructor(
+ [],
+ constexpr=True,
+ visibility="public",
+ explicit=True)
+ ]
+
+ if descriptor.supportsIndexedProperties():
+ methods.append(CGDOMJSProxyHandler_getElements(descriptor))
+ if (descriptor.operations['IndexedSetter'] is not None or
+ (descriptor.operations['NamedSetter'] is not None and
+ descriptor.interface.getExtendedAttribute('OverrideBuiltins'))):
+ methods.append(CGDOMJSProxyHandler_setCustom(descriptor))
+ if descriptor.hasNonOrdinaryGetPrototypeOf():
+ methods.append(CGDOMJSProxyHandler_getPrototypeIfOrdinary())
+ if descriptor.operations['LegacyCaller']:
+ methods.append(CGDOMJSProxyHandler_call())
+ methods.append(CGDOMJSProxyHandler_isCallable())
+
+ if descriptor.interface.getExtendedAttribute('OverrideBuiltins'):
+ parentClass = 'ShadowingDOMProxyHandler'
+ else:
+ parentClass = 'mozilla::dom::DOMProxyHandler'
+
+ CGClass.__init__(self, 'DOMProxyHandler',
+ bases=[ClassBase(parentClass)],
+ constructors=constructors,
+ methods=methods)
+
+
+class CGDOMJSProxyHandlerDeclarer(CGThing):
+ """
+ A class for declaring a DOMProxyHandler.
+ """
+ def __init__(self, handlerThing):
+ self.handlerThing = handlerThing
+
+ def declare(self):
+ # Our class declaration should happen when we're defining
+ return ""
+
+ def define(self):
+ return self.handlerThing.declare()
+
+
+class CGDOMJSProxyHandlerDefiner(CGThing):
+ """
+ A class for defining a DOMProxyHandler.
+ """
+ def __init__(self, handlerThing):
+ self.handlerThing = handlerThing
+
+ def declare(self):
+ return ""
+
+ def define(self):
+ return self.handlerThing.define()
+
+
+def stripTrailingWhitespace(text):
+ tail = '\n' if text.endswith('\n') else ''
+ lines = text.splitlines()
+ return '\n'.join(line.rstrip() for line in lines) + tail
+
+
+class MemberProperties:
+ def __init__(self):
+ self.isGenericMethod = False
+ self.isCrossOriginMethod = False
+ self.isPromiseReturningMethod = False
+ self.isGenericGetter = False
+ self.isLenientGetter = False
+ self.isCrossOriginGetter = False
+ self.isGenericSetter = False
+ self.isLenientSetter = False
+ self.isCrossOriginSetter = False
+ self.isJsonifier = False
+
+
+def memberProperties(m, descriptor):
+ props = MemberProperties()
+ if m.isMethod():
+ if m == descriptor.operations['Jsonifier']:
+ props.isGenericMethod = descriptor.needsSpecialGenericOps()
+ props.isJsonifier = True
+ elif (not m.isIdentifierLess() or m == descriptor.operations['Stringifier']):
+ if not m.isStatic() and descriptor.interface.hasInterfacePrototypeObject():
+ if descriptor.needsSpecialGenericOps():
+ if m.returnsPromise():
+ props.isPromiseReturningMethod = True
+ else:
+ props.isGenericMethod = True
+ if m.getExtendedAttribute("CrossOriginCallable"):
+ props.isCrossOriginMethod = True
+ elif m.isAttr():
+ if not m.isStatic() and descriptor.interface.hasInterfacePrototypeObject():
+ if m.hasLenientThis():
+ props.isLenientGetter = True
+ elif m.getExtendedAttribute("CrossOriginReadable"):
+ props.isCrossOriginGetter = True
+ elif descriptor.needsSpecialGenericOps():
+ props.isGenericGetter = True
+ if not m.readonly:
+ if not m.isStatic() and descriptor.interface.hasInterfacePrototypeObject():
+ if m.hasLenientThis():
+ props.isLenientSetter = True
+ elif IsCrossOriginWritable(m, descriptor):
+ props.isCrossOriginSetter = True
+ elif descriptor.needsSpecialGenericOps():
+ props.isGenericSetter = True
+ elif m.getExtendedAttribute("PutForwards"):
+ if IsCrossOriginWritable(m, descriptor):
+ props.isCrossOriginSetter = True
+ elif descriptor.needsSpecialGenericOps():
+ props.isGenericSetter = True
+ elif (m.getExtendedAttribute("Replaceable") or
+ m.getExtendedAttribute("LenientSetter")):
+ if descriptor.needsSpecialGenericOps():
+ props.isGenericSetter = True
+
+ return props
+
+
+class CGDescriptor(CGThing):
+ def __init__(self, descriptor):
+ CGThing.__init__(self)
+
+ assert not descriptor.concrete or descriptor.interface.hasInterfacePrototypeObject()
+
+ self._deps = descriptor.interface.getDeps()
+
+ cgThings = []
+ cgThings.append(CGGeneric(declare="typedef %s NativeType;\n" %
+ descriptor.nativeType))
+ parent = descriptor.interface.parent
+ if parent:
+ cgThings.append(CGGeneric("static_assert(IsRefcounted<NativeType>::value == IsRefcounted<%s::NativeType>::value,\n"
+ " \"Can't inherit from an interface with a different ownership model.\");\n" %
+ toBindingNamespace(descriptor.parentPrototypeName)))
+
+ # These are set to true if at least one non-static
+ # method/getter/setter or jsonifier exist on the interface.
+ (hasMethod, hasGetter, hasLenientGetter, hasSetter, hasLenientSetter,
+ hasPromiseReturningMethod) = False, False, False, False, False, False
+ jsonifierMethod = None
+ crossOriginMethods, crossOriginGetters, crossOriginSetters = set(), set(), set()
+ unscopableNames = list()
+ for n in descriptor.interface.namedConstructors:
+ cgThings.append(CGClassConstructor(descriptor, n,
+ NamedConstructorName(n)))
+ for m in descriptor.interface.members:
+ if m.isMethod() and m.identifier.name == 'queryInterface':
+ continue
+
+ props = memberProperties(m, descriptor)
+
+ if m.isMethod():
+ if m.getExtendedAttribute("Unscopable"):
+ assert not m.isStatic()
+ unscopableNames.append(m.identifier.name)
+ if props.isJsonifier:
+ jsonifierMethod = m
+ elif not m.isIdentifierLess() or m == descriptor.operations['Stringifier']:
+ if m.isStatic():
+ assert descriptor.interface.hasInterfaceObject()
+ cgThings.append(CGStaticMethod(descriptor, m))
+ if m.returnsPromise():
+ cgThings.append(CGStaticMethodJitinfo(m))
+ elif descriptor.interface.hasInterfacePrototypeObject():
+ specializedMethod = CGSpecializedMethod(descriptor, m)
+ cgThings.append(specializedMethod)
+ if m.returnsPromise():
+ cgThings.append(CGMethodPromiseWrapper(descriptor, specializedMethod))
+ cgThings.append(CGMemberJITInfo(descriptor, m))
+ if props.isCrossOriginMethod:
+ crossOriginMethods.add(m.identifier.name)
+ # If we've hit the maplike/setlike member itself, go ahead and
+ # generate its convenience functions.
+ elif m.isMaplikeOrSetlike():
+ cgThings.append(CGMaplikeOrSetlikeHelperGenerator(descriptor, m))
+ elif m.isAttr():
+ if m.stringifier:
+ raise TypeError("Stringifier attributes not supported yet. "
+ "See bug 824857.\n"
+ "%s" % m.location)
+ if m.getExtendedAttribute("Unscopable"):
+ assert not m.isStatic()
+ unscopableNames.append(m.identifier.name)
+ if m.isStatic():
+ assert descriptor.interface.hasInterfaceObject()
+ cgThings.append(CGStaticGetter(descriptor, m))
+ elif descriptor.interface.hasInterfacePrototypeObject():
+ if isNonExposedNavigatorObjectGetter(m, descriptor):
+ continue
+ cgThings.append(CGSpecializedGetter(descriptor, m))
+ if props.isCrossOriginGetter:
+ crossOriginGetters.add(m.identifier.name)
+ if not m.readonly:
+ if m.isStatic():
+ assert descriptor.interface.hasInterfaceObject()
+ cgThings.append(CGStaticSetter(descriptor, m))
+ elif descriptor.interface.hasInterfacePrototypeObject():
+ cgThings.append(CGSpecializedSetter(descriptor, m))
+ if props.isCrossOriginSetter:
+ crossOriginSetters.add(m.identifier.name)
+ elif m.getExtendedAttribute("PutForwards"):
+ cgThings.append(CGSpecializedForwardingSetter(descriptor, m))
+ if props.isCrossOriginSetter:
+ crossOriginSetters.add(m.identifier.name)
+ elif m.getExtendedAttribute("Replaceable"):
+ cgThings.append(CGSpecializedReplaceableSetter(descriptor, m))
+ elif m.getExtendedAttribute("LenientSetter"):
+ cgThings.append(CGSpecializedLenientSetter(descriptor, m))
+ if (not m.isStatic() and
+ descriptor.interface.hasInterfacePrototypeObject()):
+ cgThings.append(CGMemberJITInfo(descriptor, m))
+
+ hasMethod = hasMethod or props.isGenericMethod
+ hasPromiseReturningMethod = (hasPromiseReturningMethod or
+ props.isPromiseReturningMethod)
+ hasGetter = hasGetter or props.isGenericGetter
+ hasLenientGetter = hasLenientGetter or props.isLenientGetter
+ hasSetter = hasSetter or props.isGenericSetter
+ hasLenientSetter = hasLenientSetter or props.isLenientSetter
+
+ if jsonifierMethod:
+ cgThings.append(CGJsonifyAttributesMethod(descriptor))
+ cgThings.append(CGJsonifierMethod(descriptor, jsonifierMethod))
+ cgThings.append(CGMemberJITInfo(descriptor, jsonifierMethod))
+ if hasMethod:
+ cgThings.append(CGGenericMethod(descriptor))
+ if hasPromiseReturningMethod:
+ cgThings.append(CGGenericPromiseReturningMethod(descriptor))
+ if len(crossOriginMethods):
+ cgThings.append(CGGenericMethod(descriptor,
+ allowCrossOriginThis=True))
+ if hasGetter:
+ cgThings.append(CGGenericGetter(descriptor))
+ if hasLenientGetter:
+ cgThings.append(CGGenericGetter(descriptor, lenientThis=True))
+ if len(crossOriginGetters):
+ cgThings.append(CGGenericGetter(descriptor,
+ allowCrossOriginThis=True))
+ if hasSetter:
+ cgThings.append(CGGenericSetter(descriptor))
+ if hasLenientSetter:
+ cgThings.append(CGGenericSetter(descriptor, lenientThis=True))
+ if len(crossOriginSetters):
+ cgThings.append(CGGenericSetter(descriptor,
+ allowCrossOriginThis=True))
+
+ if descriptor.interface.isNavigatorProperty():
+ cgThings.append(CGConstructNavigatorObject(descriptor))
+
+ if descriptor.concrete and not descriptor.proxy:
+ if wantsAddProperty(descriptor):
+ cgThings.append(CGAddPropertyHook(descriptor))
+
+ # Always have a finalize hook, regardless of whether the class
+ # wants a custom hook.
+ cgThings.append(CGClassFinalizeHook(descriptor))
+
+ if descriptor.concrete and descriptor.wrapperCache:
+ cgThings.append(CGClassObjectMovedHook(descriptor))
+
+ # Generate the _ClearCachedFooValue methods before the property arrays that use them.
+ if descriptor.interface.isJSImplemented():
+ for m in clearableCachedAttrs(descriptor):
+ cgThings.append(CGJSImplClearCachedValueMethod(descriptor, m))
+
+ # Need to output our generated hasinstance bits before
+ # PropertyArrays tries to use them.
+ if (descriptor.interface.hasInterfaceObject() and
+ NeedsGeneratedHasInstance(descriptor)):
+ cgThings.append(CGHasInstanceHook(descriptor))
+
+ properties = PropertyArrays(descriptor)
+ cgThings.append(CGGeneric(define=str(properties)))
+ cgThings.append(CGNativeProperties(descriptor, properties))
+
+ if descriptor.interface.hasInterfaceObject():
+ cgThings.append(CGClassConstructor(descriptor,
+ descriptor.interface.ctor()))
+ cgThings.append(CGInterfaceObjectJSClass(descriptor, properties))
+ cgThings.append(CGNamedConstructors(descriptor))
+
+ cgThings.append(CGLegacyCallHook(descriptor))
+ if descriptor.interface.getExtendedAttribute("NeedResolve"):
+ cgThings.append(CGResolveHook(descriptor))
+ cgThings.append(CGMayResolveHook(descriptor))
+ cgThings.append(CGEnumerateHook(descriptor))
+
+ if descriptor.hasNamedPropertiesObject:
+ cgThings.append(CGGetNamedPropertiesObjectMethod(descriptor))
+
+ if descriptor.interface.hasInterfacePrototypeObject():
+ cgThings.append(CGPrototypeJSClass(descriptor, properties))
+
+ if ((descriptor.interface.hasInterfaceObject() or descriptor.interface.isNavigatorProperty()) and
+ not descriptor.interface.isExternal() and
+ descriptor.isExposedConditionally()):
+ cgThings.append(CGConstructorEnabled(descriptor))
+
+ if descriptor.registersGlobalNamesOnWindow:
+ cgThings.append(CGDefineDOMInterfaceMethod(descriptor))
+
+ if (descriptor.interface.hasMembersInSlots() and
+ descriptor.interface.hasChildInterfaces()):
+ raise TypeError("We don't support members in slots on "
+ "non-leaf interfaces like %s" %
+ descriptor.interface.identifier.name)
+
+ if descriptor.concrete:
+ if descriptor.proxy:
+ if descriptor.interface.totalMembersInSlots != 0:
+ raise TypeError("We can't have extra reserved slots for "
+ "proxy interface %s" %
+ descriptor.interface.identifier.name)
+ cgThings.append(CGGeneric(fill(
+ """
+ static_assert(IsBaseOf<nsISupports, ${nativeType} >::value,
+ "We don't support non-nsISupports native classes for "
+ "proxy-based bindings yet");
+
+ """,
+ nativeType=descriptor.nativeType)))
+ if not descriptor.wrapperCache:
+ raise TypeError("We need a wrappercache to support expandos for proxy-based "
+ "bindings (" + descriptor.name + ")")
+ handlerThing = CGDOMJSProxyHandler(descriptor)
+ cgThings.append(CGDOMJSProxyHandlerDeclarer(handlerThing))
+ cgThings.append(CGProxyIsProxy(descriptor))
+ cgThings.append(CGProxyUnwrap(descriptor))
+ cgThings.append(CGDOMJSProxyHandlerDefiner(handlerThing))
+ cgThings.append(CGDOMProxyJSClass(descriptor))
+ else:
+ cgThings.append(CGDOMJSClass(descriptor))
+ cgThings.append(CGGetJSClassMethod(descriptor))
+ if descriptor.interface.hasMembersInSlots():
+ cgThings.append(CGUpdateMemberSlotsMethod(descriptor))
+
+ if descriptor.isGlobal():
+ assert descriptor.wrapperCache
+ cgThings.append(CGWrapGlobalMethod(descriptor, properties))
+ elif descriptor.wrapperCache:
+ cgThings.append(CGWrapWithCacheMethod(descriptor, properties))
+ cgThings.append(CGWrapMethod(descriptor))
+ else:
+ cgThings.append(CGWrapNonWrapperCacheMethod(descriptor,
+ properties))
+
+ # Set up our Xray callbacks as needed. This needs to come
+ # after we have our DOMProxyHandler defined.
+ if descriptor.wantsXrays:
+ if descriptor.concrete and descriptor.proxy:
+ cgThings.append(CGResolveOwnProperty(descriptor))
+ cgThings.append(CGEnumerateOwnProperties(descriptor))
+ if descriptor.needsXrayNamedDeleterHook():
+ cgThings.append(CGDeleteNamedProperty(descriptor))
+ elif descriptor.needsXrayResolveHooks():
+ cgThings.append(CGResolveOwnPropertyViaResolve(descriptor))
+ cgThings.append(CGEnumerateOwnPropertiesViaGetOwnPropertyNames(descriptor))
+ if descriptor.wantsXrayExpandoClass:
+ cgThings.append(CGXrayExpandoJSClass(descriptor))
+
+ # Now that we have our ResolveOwnProperty/EnumerateOwnProperties stuff
+ # done, set up our NativePropertyHooks.
+ cgThings.append(CGNativePropertyHooks(descriptor, properties))
+
+ # If we're not wrappercached, we don't know how to clear our
+ # cached values, since we can't get at the JSObject.
+ if descriptor.wrapperCache:
+ cgThings.extend(CGClearCachedValueMethod(descriptor, m) for
+ m in clearableCachedAttrs(descriptor))
+
+ haveUnscopables = (len(unscopableNames) != 0 and
+ descriptor.interface.hasInterfacePrototypeObject())
+ if haveUnscopables:
+ cgThings.append(
+ CGList([CGGeneric("static const char* const unscopableNames[] = {"),
+ CGIndenter(CGList([CGGeneric('"%s"' % name) for
+ name in unscopableNames] +
+ [CGGeneric("nullptr")], ",\n")),
+ CGGeneric("};\n")], "\n"))
+
+ # CGCreateInterfaceObjectsMethod needs to come after our
+ # CGDOMJSClass and unscopables, if any.
+ cgThings.append(CGCreateInterfaceObjectsMethod(descriptor, properties,
+ haveUnscopables))
+
+ # CGGetProtoObjectMethod and CGGetConstructorObjectMethod need
+ # to come after CGCreateInterfaceObjectsMethod.
+ if descriptor.interface.hasInterfacePrototypeObject():
+ cgThings.append(CGGetProtoObjectHandleMethod(descriptor))
+ if descriptor.interface.hasChildInterfaces():
+ cgThings.append(CGGetProtoObjectMethod(descriptor))
+ if descriptor.interface.hasInterfaceObject():
+ cgThings.append(CGGetConstructorObjectHandleMethod(descriptor))
+ cgThings.append(CGGetConstructorObjectMethod(descriptor))
+
+ # See whether we need we need to generate an IsPermitted method
+ if crossOriginGetters or crossOriginSetters or crossOriginMethods:
+ cgThings.append(CGIsPermittedMethod(descriptor,
+ crossOriginGetters,
+ crossOriginSetters,
+ crossOriginMethods))
+
+ cgThings = CGList((CGIndenter(t, declareOnly=True) for t in cgThings), "\n")
+ cgThings = CGWrapper(cgThings, pre='\n', post='\n')
+ self.cgRoot = CGWrapper(CGNamespace(toBindingNamespace(descriptor.name),
+ cgThings),
+ post='\n')
+
+ def declare(self):
+ return self.cgRoot.declare()
+
+ def define(self):
+ return self.cgRoot.define()
+
+ def deps(self):
+ return self._deps
+
+
+class CGNamespacedEnum(CGThing):
+ def __init__(self, namespace, enumName, names, values, comment=""):
+
+ if not values:
+ values = []
+
+ # Account for explicit enum values.
+ entries = []
+ for i in range(0, len(names)):
+ if len(values) > i and values[i] is not None:
+ entry = "%s = %s" % (names[i], values[i])
+ else:
+ entry = names[i]
+ entries.append(entry)
+
+ # Append a Count.
+ entries.append('_' + enumName + '_Count')
+
+ # Indent.
+ entries = [' ' + e for e in entries]
+
+ # Build the enum body.
+ enumstr = comment + 'enum %s : uint16_t\n{\n%s\n};\n' % (enumName, ',\n'.join(entries))
+ curr = CGGeneric(declare=enumstr)
+
+ # Add some whitespace padding.
+ curr = CGWrapper(curr, pre='\n', post='\n')
+
+ # Add the namespace.
+ curr = CGNamespace(namespace, curr)
+
+ # Add the typedef
+ typedef = '\ntypedef %s::%s %s;\n\n' % (namespace, enumName, enumName)
+ curr = CGList([curr, CGGeneric(declare=typedef)])
+
+ # Save the result.
+ self.node = curr
+
+ def declare(self):
+ return self.node.declare()
+
+ def define(self):
+ return ""
+
+
+def initIdsClassMethod(identifiers, atomCacheName):
+ idinit = ['!atomsCache->%s.init(cx, "%s")' %
+ (CGDictionary.makeIdName(id),
+ id)
+ for id in identifiers]
+ idinit.reverse()
+ body = fill(
+ """
+ MOZ_ASSERT(!*reinterpret_cast<jsid**>(atomsCache));
+
+ // Initialize these in reverse order so that any failure leaves the first one
+ // uninitialized.
+ if (${idinit}) {
+ return false;
+ }
+ return true;
+ """,
+ idinit=" ||\n ".join(idinit))
+ return ClassMethod("InitIds", "bool", [
+ Argument("JSContext*", "cx"),
+ Argument("%s*" % atomCacheName, "atomsCache")
+ ], static=True, body=body, visibility="private")
+
+
+class CGDictionary(CGThing):
+ def __init__(self, dictionary, descriptorProvider):
+ self.dictionary = dictionary
+ self.descriptorProvider = descriptorProvider
+ self.needToInitIds = len(dictionary.members) > 0
+ self.memberInfo = [
+ (member,
+ getJSToNativeConversionInfo(
+ member.type,
+ descriptorProvider,
+ isEnforceRange=member.enforceRange,
+ isClamp=member.clamp,
+ isMember="Dictionary",
+ isOptional=member.canHaveMissingValue(),
+ defaultValue=member.defaultValue,
+ sourceDescription=self.getMemberSourceDescription(member)))
+ for member in dictionary.members]
+
+ # If we have a union member containing something in the same
+ # file as us, bail: the C++ includes won't work out.
+ for member in dictionary.members:
+ type = member.type.unroll()
+ if type.isUnion():
+ for t in type.flatMemberTypes:
+ if (t.isDictionary() and
+ CGHeaders.getDeclarationFilename(t.inner) ==
+ CGHeaders.getDeclarationFilename(dictionary)):
+ raise TypeError(
+ "Dictionary contains a union that contains a "
+ "dictionary in the same WebIDL file. This won't "
+ "compile. Move the inner dictionary to a "
+ "different file.\n%s\n%s" %
+ (t.location, t.inner.location))
+ self.structs = self.getStructs()
+
+ def declare(self):
+ return self.structs.declare()
+
+ def define(self):
+ return self.structs.define()
+
+ def base(self):
+ if self.dictionary.parent:
+ return self.makeClassName(self.dictionary.parent)
+ return "DictionaryBase"
+
+ def initMethod(self):
+ """
+ This function outputs the body of the Init() method for the dictionary.
+
+ For the most part, this is some bookkeeping for our atoms so
+ we can avoid atomizing strings all the time, then we just spit
+ out the getMemberConversion() output for each member,
+ separated by newlines.
+
+ """
+ body = dedent("""
+ // Passing a null JSContext is OK only if we're initing from null,
+ // Since in that case we will not have to do any property gets
+ MOZ_ASSERT_IF(!cx, val.isNull());
+ """)
+
+ if self.needToInitIds:
+ body += fill(
+ """
+ ${dictName}Atoms* atomsCache = nullptr;
+ if (cx) {
+ atomsCache = GetAtomCache<${dictName}Atoms>(cx);
+ if (!*reinterpret_cast<jsid**>(atomsCache) && !InitIds(cx, atomsCache)) {
+ return false;
+ }
+ }
+
+ """,
+ dictName=self.makeClassName(self.dictionary))
+
+ if self.dictionary.parent:
+ body += fill(
+ """
+ // Per spec, we init the parent's members first
+ if (!${dictName}::Init(cx, val)) {
+ return false;
+ }
+
+ """,
+ dictName=self.makeClassName(self.dictionary.parent))
+ else:
+ body += dedent(
+ """
+ { // scope for isConvertible
+ bool isConvertible;
+ if (!IsConvertibleToDictionary(cx, val, &isConvertible)) {
+ return false;
+ }
+ if (!isConvertible) {
+ return ThrowErrorMessage(cx, MSG_NOT_DICTIONARY, sourceDescription);
+ }
+ }
+
+ """)
+
+ memberInits = [self.getMemberConversion(m).define()
+ for m in self.memberInfo]
+ if memberInits:
+ body += fill(
+ """
+ bool isNull = val.isNullOrUndefined();
+ // We only need these if !isNull, in which case we have |cx|.
+ Maybe<JS::Rooted<JSObject *> > object;
+ Maybe<JS::Rooted<JS::Value> > temp;
+ if (!isNull) {
+ MOZ_ASSERT(cx);
+ object.emplace(cx, &val.toObject());
+ temp.emplace(cx);
+ }
+ $*{memberInits}
+ """,
+ memberInits="\n".join(memberInits))
+
+ body += "return true;\n"
+
+ return ClassMethod("Init", "bool", [
+ Argument('JSContext*', 'cx'),
+ Argument('JS::Handle<JS::Value>', 'val'),
+ Argument('const char*', 'sourceDescription', default='"Value"'),
+ Argument('bool', 'passedToJSImpl', default='false')
+ ], body=body)
+
+ def initFromJSONMethod(self):
+ return ClassMethod(
+ "Init", "bool",
+ [Argument('const nsAString&', 'aJSON')],
+ body=dedent("""
+ AutoJSAPI jsapi;
+ JSObject* cleanGlobal = SimpleGlobalObject::Create(SimpleGlobalObject::GlobalType::BindingDetail);
+ if (!cleanGlobal) {
+ return false;
+ }
+ if (!jsapi.Init(cleanGlobal)) {
+ return false;
+ }
+ JSContext* cx = jsapi.cx();
+ JS::Rooted<JS::Value> json(cx);
+ bool ok = ParseJSON(cx, aJSON, &json);
+ NS_ENSURE_TRUE(ok, false);
+ return Init(cx, json);
+ """))
+
+ def toJSONMethod(self):
+ return ClassMethod(
+ "ToJSON", "bool",
+ [Argument('nsAString&', 'aJSON')],
+ body=dedent("""
+ AutoJSAPI jsapi;
+ jsapi.Init();
+ JSContext *cx = jsapi.cx();
+ // It's safe to use UnprivilegedJunkScopeOrWorkerGlobal here
+ // because we'll only be creating objects, in ways that have no
+ // side-effects, followed by a call to JS::ToJSONMaybeSafely,
+ // which likewise guarantees no side-effects for the sorts of
+ // things we will pass it.
+ JSAutoCompartment ac(cx, binding_detail::UnprivilegedJunkScopeOrWorkerGlobal());
+ JS::Rooted<JS::Value> val(cx);
+ if (!ToObjectInternal(cx, &val)) {
+ return false;
+ }
+ JS::Rooted<JSObject*> obj(cx, &val.toObject());
+ return StringifyToJSON(cx, obj, aJSON);
+ """), const=True)
+
+ def toObjectInternalMethod(self):
+ body = ""
+ if self.needToInitIds:
+ body += fill(
+ """
+ ${dictName}Atoms* atomsCache = GetAtomCache<${dictName}Atoms>(cx);
+ if (!*reinterpret_cast<jsid**>(atomsCache) && !InitIds(cx, atomsCache)) {
+ return false;
+ }
+
+ """,
+ dictName=self.makeClassName(self.dictionary))
+
+ if self.dictionary.parent:
+ body += fill(
+ """
+ // Per spec, we define the parent's members first
+ if (!${dictName}::ToObjectInternal(cx, rval)) {
+ return false;
+ }
+ JS::Rooted<JSObject*> obj(cx, &rval.toObject());
+
+ """,
+ dictName=self.makeClassName(self.dictionary.parent))
+ else:
+ body += dedent(
+ """
+ JS::Rooted<JSObject*> obj(cx, JS_NewPlainObject(cx));
+ if (!obj) {
+ return false;
+ }
+ rval.set(JS::ObjectValue(*obj));
+
+ """)
+
+ if self.memberInfo:
+ body += "\n".join(self.getMemberDefinition(m).define()
+ for m in self.memberInfo)
+ body += "\nreturn true;\n"
+
+ return ClassMethod("ToObjectInternal", "bool", [
+ Argument('JSContext*', 'cx'),
+ Argument('JS::MutableHandle<JS::Value>', 'rval'),
+ ], const=True, body=body)
+
+ def initIdsMethod(self):
+ assert self.needToInitIds
+ return initIdsClassMethod([m.identifier.name for m in self.dictionary.members],
+ "%sAtoms" % self.makeClassName(self.dictionary))
+
+ def traceDictionaryMethod(self):
+ body = ""
+ if self.dictionary.parent:
+ cls = self.makeClassName(self.dictionary.parent)
+ body += "%s::TraceDictionary(trc);\n" % cls
+
+ memberTraces = [self.getMemberTrace(m)
+ for m in self.dictionary.members
+ if typeNeedsRooting(m.type)]
+
+ if memberTraces:
+ body += "\n".join(memberTraces)
+
+ return ClassMethod("TraceDictionary", "void", [
+ Argument("JSTracer*", "trc"),
+ ], body=body)
+
+ def assignmentOperator(self):
+ body = CGList([])
+ if self.dictionary.parent:
+ body.append(CGGeneric(
+ "%s::operator=(aOther);\n" %
+ self.makeClassName(self.dictionary.parent)))
+ for m, _ in self.memberInfo:
+ memberName = self.makeMemberName(m.identifier.name)
+ if m.canHaveMissingValue():
+ memberAssign = CGGeneric(fill(
+ """
+ ${name}.Reset();
+ if (aOther.${name}.WasPassed()) {
+ ${name}.Construct(aOther.${name}.Value());
+ }
+ """,
+ name=memberName))
+ else:
+ memberAssign = CGGeneric(
+ "%s = aOther.%s;\n" % (memberName, memberName))
+ body.append(memberAssign)
+ return ClassMethod(
+ "operator=", "void",
+ [Argument("const %s&" % self.makeClassName(self.dictionary),
+ "aOther")],
+ body=body.define())
+
+ def getStructs(self):
+ d = self.dictionary
+ selfName = self.makeClassName(d)
+ members = [ClassMember(self.makeMemberName(m[0].identifier.name),
+ self.getMemberType(m),
+ visibility="public",
+ body=self.getMemberInitializer(m),
+ hasIgnoreInitCheckFlag=True)
+ for m in self.memberInfo]
+ if d.parent:
+ # We always want to init our parent with our non-initializing
+ # constructor arg, because either we're about to init ourselves (and
+ # hence our parent) or we don't want any init happening.
+ baseConstructors = [
+ "%s(%s)" % (self.makeClassName(d.parent),
+ self.getNonInitializingCtorArg())
+ ]
+ else:
+ baseConstructors = None
+ ctors = [
+ ClassConstructor(
+ [],
+ visibility="public",
+ baseConstructors=baseConstructors,
+ body=(
+ "// Safe to pass a null context if we pass a null value\n"
+ "Init(nullptr, JS::NullHandleValue);\n")),
+ ClassConstructor(
+ [Argument("const FastDictionaryInitializer&", "")],
+ visibility="public",
+ baseConstructors=baseConstructors,
+ explicit=True,
+ bodyInHeader=True,
+ body='// Do nothing here; this is used by our "Fast" subclass\n')
+ ]
+ methods = []
+
+ if self.needToInitIds:
+ methods.append(self.initIdsMethod())
+
+ methods.append(self.initMethod())
+ canBeRepresentedAsJSON = self.dictionarySafeToJSONify(self.dictionary)
+ if canBeRepresentedAsJSON:
+ methods.append(self.initFromJSONMethod())
+ try:
+ methods.append(self.toObjectInternalMethod())
+ if canBeRepresentedAsJSON:
+ methods.append(self.toJSONMethod())
+ except MethodNotNewObjectError:
+ # If we can't have a ToObjectInternal() because one of our members
+ # can only be returned from [NewObject] methods, then just skip
+ # generating ToObjectInternal() and ToJSON (since the latter depens
+ # on the former).
+ pass
+ methods.append(self.traceDictionaryMethod())
+
+ if CGDictionary.isDictionaryCopyConstructible(d):
+ disallowCopyConstruction = False
+ # Note: no base constructors because our operator= will
+ # deal with that.
+ ctors.append(ClassConstructor([Argument("const %s&" % selfName,
+ "aOther")],
+ bodyInHeader=True,
+ visibility="public",
+ explicit=True,
+ body="*this = aOther;\n"))
+ methods.append(self.assignmentOperator())
+ else:
+ disallowCopyConstruction = True
+
+ struct = CGClass(selfName,
+ bases=[ClassBase(self.base())],
+ members=members,
+ constructors=ctors,
+ methods=methods,
+ isStruct=True,
+ disallowCopyConstruction=disallowCopyConstruction)
+
+ fastDictionaryCtor = ClassConstructor(
+ [],
+ visibility="public",
+ bodyInHeader=True,
+ baseConstructors=["%s(%s)" %
+ (selfName,
+ self.getNonInitializingCtorArg())],
+ body="// Doesn't matter what int we pass to the parent constructor\n")
+
+ fastStruct = CGClass("Fast" + selfName,
+ bases=[ClassBase(selfName)],
+ constructors=[fastDictionaryCtor],
+ isStruct=True)
+
+ return CGList([struct,
+ CGNamespace('binding_detail', fastStruct)],
+ "\n")
+
+ def deps(self):
+ return self.dictionary.getDeps()
+
+ @staticmethod
+ def makeDictionaryName(dictionary):
+ return dictionary.identifier.name
+
+ def makeClassName(self, dictionary):
+ return self.makeDictionaryName(dictionary)
+
+ @staticmethod
+ def makeMemberName(name):
+ return "m" + name[0].upper() + IDLToCIdentifier(name[1:])
+
+ def getMemberType(self, memberInfo):
+ _, conversionInfo = memberInfo
+ # We can't handle having a holderType here
+ assert conversionInfo.holderType is None
+ declType = conversionInfo.declType
+ if conversionInfo.dealWithOptional:
+ declType = CGTemplatedType("Optional", declType)
+ return declType.define()
+
+ def getMemberConversion(self, memberInfo):
+ """
+ A function that outputs the initialization of a single dictionary
+ member from the given dictionary value.
+
+ We start with our conversionInfo, which tells us how to
+ convert a JS::Value to whatever type this member is. We
+ substiture the template from the conversionInfo with values
+ that point to our "temp" JS::Value and our member (which is
+ the C++ value we want to produce). The output is a string of
+ code to do the conversion. We store this string in
+ conversionReplacements["convert"].
+
+ Now we have three different ways we might use (or skip) this
+ string of code, depending on whether the value is required,
+ optional with default value, or optional without default
+ value. We set up a template in the 'conversion' variable for
+ exactly how to do this, then substitute into it from the
+ conversionReplacements dictionary.
+ """
+ member, conversionInfo = memberInfo
+ replacements = {
+ "val": "temp.ref()",
+ "maybeMutableVal": "temp.ptr()",
+ "declName": self.makeMemberName(member.identifier.name),
+ # We need a holder name for external interfaces, but
+ # it's scoped down to the conversion so we can just use
+ # anything we want.
+ "holderName": "holder",
+ "passedToJSImpl": "passedToJSImpl"
+ }
+ # We can't handle having a holderType here
+ assert conversionInfo.holderType is None
+ if conversionInfo.dealWithOptional:
+ replacements["declName"] = "(" + replacements["declName"] + ".Value())"
+ if member.defaultValue:
+ replacements["haveValue"] = "!isNull && !temp->isUndefined()"
+
+ propId = self.makeIdName(member.identifier.name)
+ propGet = ("JS_GetPropertyById(cx, *object, atomsCache->%s, temp.ptr())" %
+ propId)
+
+ conversionReplacements = {
+ "prop": self.makeMemberName(member.identifier.name),
+ "convert": string.Template(conversionInfo.template).substitute(replacements),
+ "propGet": propGet
+ }
+ # The conversion code will only run where a default value or a value passed
+ # by the author needs to get converted, so we can remember if we have any
+ # members present here.
+ conversionReplacements["convert"] += "mIsAnyMemberPresent = true;\n"
+ setTempValue = CGGeneric(dedent(
+ """
+ if (!${propGet}) {
+ return false;
+ }
+ """))
+ conditions = getConditionList(member, "cx", "*object")
+ if len(conditions) != 0:
+ setTempValue = CGIfElseWrapper(conditions.define(),
+ setTempValue,
+ CGGeneric("temp->setUndefined();\n"))
+ setTempValue = CGIfWrapper(setTempValue, "!isNull")
+ conversion = setTempValue.define()
+ if member.defaultValue:
+ if (member.type.isUnion() and
+ (not member.type.nullable() or
+ not isinstance(member.defaultValue, IDLNullValue))):
+ # Since this has a default value, it might have been initialized
+ # already. Go ahead and uninit it before we try to init it
+ # again.
+ memberName = self.makeMemberName(member.identifier.name)
+ if member.type.nullable():
+ conversion += fill(
+ """
+ if (!${memberName}.IsNull()) {
+ ${memberName}.Value().Uninit();
+ }
+ """,
+ memberName=memberName)
+ else:
+ conversion += "%s.Uninit();\n" % memberName
+ conversion += "${convert}"
+ elif not conversionInfo.dealWithOptional:
+ # We're required, but have no default value. Make sure
+ # that we throw if we have no value provided.
+ conversion += dedent(
+ """
+ if (!isNull && !temp->isUndefined()) {
+ ${convert}
+ } else if (cx) {
+ // Don't error out if we have no cx. In that
+ // situation the caller is default-constructing us and we'll
+ // just assume they know what they're doing.
+ return ThrowErrorMessage(cx, MSG_MISSING_REQUIRED_DICTIONARY_MEMBER,
+ "%s");
+ }
+ """ % self.getMemberSourceDescription(member))
+ conversionReplacements["convert"] = indent(conversionReplacements["convert"]).rstrip()
+ else:
+ conversion += (
+ "if (!isNull && !temp->isUndefined()) {\n"
+ " ${prop}.Construct();\n"
+ "${convert}"
+ "}\n")
+ conversionReplacements["convert"] = indent(conversionReplacements["convert"])
+
+ return CGGeneric(
+ string.Template(conversion).substitute(conversionReplacements))
+
+ def getMemberDefinition(self, memberInfo):
+ member = memberInfo[0]
+ declType = memberInfo[1].declType
+ memberLoc = self.makeMemberName(member.identifier.name)
+ if not member.canHaveMissingValue():
+ memberData = memberLoc
+ else:
+ # The data is inside the Optional<>
+ memberData = "%s.InternalValue()" % memberLoc
+
+ # If you have to change this list (which you shouldn't!), make sure it
+ # continues to match the list in test_Object.prototype_props.html
+ if (member.identifier.name in
+ ["constructor", "toSource", "toString", "toLocaleString", "valueOf",
+ "watch", "unwatch", "hasOwnProperty", "isPrototypeOf",
+ "propertyIsEnumerable", "__defineGetter__", "__defineSetter__",
+ "__lookupGetter__", "__lookupSetter__", "__proto__"]):
+ raise TypeError("'%s' member of %s dictionary shadows "
+ "a property of Object.prototype, and Xrays to "
+ "Object can't handle that.\n"
+ "%s" %
+ (member.identifier.name,
+ self.dictionary.identifier.name,
+ member.location))
+
+ propDef = (
+ 'JS_DefinePropertyById(cx, obj, atomsCache->%s, temp, JSPROP_ENUMERATE)' %
+ self.makeIdName(member.identifier.name))
+
+ innerTemplate = wrapForType(
+ member.type, self.descriptorProvider,
+ {
+ 'result': "currentValue",
+ 'successCode': ("if (!%s) {\n"
+ " return false;\n"
+ "}\n"
+ "break;\n" % propDef),
+ 'jsvalRef': "temp",
+ 'jsvalHandle': "&temp",
+ 'returnsNewObject': False,
+ # 'obj' can just be allowed to be the string "obj", since that
+ # will be our dictionary object, which is presumably itself in
+ # the right scope.
+ 'typedArraysAreStructs': True
+ })
+ conversion = CGGeneric(innerTemplate)
+ conversion = CGWrapper(conversion,
+ pre=("JS::Rooted<JS::Value> temp(cx);\n"
+ "%s const & currentValue = %s;\n" %
+ (declType.define(), memberData)
+ ))
+
+ # Now make sure that our successCode can actually break out of the
+ # conversion. This incidentally gives us a scope for 'temp' and
+ # 'currentValue'.
+ conversion = CGWrapper(
+ CGIndenter(conversion),
+ pre=("do {\n"
+ " // block for our 'break' successCode and scope for 'temp' and 'currentValue'\n"),
+ post="} while(0);\n")
+ if member.canHaveMissingValue():
+ # Only do the conversion if we have a value
+ conversion = CGIfWrapper(conversion, "%s.WasPassed()" % memberLoc)
+ conditions = getConditionList(member, "cx", "obj")
+ if len(conditions) != 0:
+ conversion = CGIfWrapper(conversion, conditions.define())
+ return conversion
+
+ def getMemberTrace(self, member):
+ type = member.type
+ assert typeNeedsRooting(type)
+ memberLoc = self.makeMemberName(member.identifier.name)
+ if not member.canHaveMissingValue():
+ memberData = memberLoc
+ else:
+ # The data is inside the Optional<>
+ memberData = "%s.Value()" % memberLoc
+
+ memberName = "%s.%s" % (self.makeClassName(self.dictionary),
+ memberLoc)
+
+ if type.isObject():
+ trace = CGGeneric('JS::UnsafeTraceRoot(trc, %s, "%s");\n' %
+ ("&"+memberData, memberName))
+ if type.nullable():
+ trace = CGIfWrapper(trace, memberData)
+ elif type.isAny():
+ trace = CGGeneric('JS::UnsafeTraceRoot(trc, %s, "%s");\n' %
+ ("&"+memberData, memberName))
+ elif (type.isSequence() or type.isDictionary() or
+ type.isSpiderMonkeyInterface() or type.isUnion()):
+ if type.nullable():
+ memberNullable = memberData
+ memberData = "%s.Value()" % memberData
+ if type.isSequence():
+ trace = CGGeneric('DoTraceSequence(trc, %s);\n' % memberData)
+ elif type.isDictionary():
+ trace = CGGeneric('%s.TraceDictionary(trc);\n' % memberData)
+ elif type.isUnion():
+ trace = CGGeneric('%s.TraceUnion(trc);\n' % memberData)
+ else:
+ assert type.isSpiderMonkeyInterface()
+ trace = CGGeneric('%s.TraceSelf(trc);\n' % memberData)
+ if type.nullable():
+ trace = CGIfWrapper(trace, "!%s.IsNull()" % memberNullable)
+ elif type.isMozMap():
+ # If you implement this, add a MozMap<object> to
+ # TestInterfaceJSDictionary and test it in test_bug1036214.html
+ # to make sure we end up with the correct security properties.
+ assert False
+ else:
+ assert False # unknown type
+
+ if member.canHaveMissingValue():
+ trace = CGIfWrapper(trace, "%s.WasPassed()" % memberLoc)
+
+ return trace.define()
+
+ def getMemberInitializer(self, memberInfo):
+ """
+ Get the right initializer for the member. Most members don't need one,
+ but we need to pre-initialize 'any' and 'object' that have a default
+ value, so they're safe to trace at all times.
+ """
+ member, _ = memberInfo
+ if member.canHaveMissingValue():
+ # Allowed missing value means no need to set it up front, since it's
+ # inside an Optional and won't get traced until it's actually set
+ # up.
+ return None
+ type = member.type
+ if type.isAny():
+ return "JS::UndefinedValue()"
+ if type.isObject():
+ return "nullptr"
+ if type.isDictionary():
+ # When we construct ourselves, we don't want to init our member
+ # dictionaries. Either we're being constructed-but-not-initialized
+ # ourselves (and then we don't want to init them) or we're about to
+ # init ourselves and then we'll init them anyway.
+ return CGDictionary.getNonInitializingCtorArg()
+ return None
+
+ def getMemberSourceDescription(self, member):
+ return ("'%s' member of %s" %
+ (member.identifier.name, self.dictionary.identifier.name))
+
+ @staticmethod
+ def makeIdName(name):
+ return IDLToCIdentifier(name) + "_id"
+
+ @staticmethod
+ def getNonInitializingCtorArg():
+ return "FastDictionaryInitializer()"
+
+ @staticmethod
+ def isDictionaryCopyConstructible(dictionary):
+ if (dictionary.parent and
+ not CGDictionary.isDictionaryCopyConstructible(dictionary.parent)):
+ return False
+ return all(isTypeCopyConstructible(m.type) for m in dictionary.members)
+
+ @staticmethod
+ def typeSafeToJSONify(type):
+ """
+ Determine whether the given type is safe to convert to JSON. The
+ restriction is that this needs to be safe while in a global controlled
+ by an adversary, and "safe" means no side-effects when the JS
+ representation of this type is converted to JSON. That means that we
+ have to be pretty restrictive about what things we can allow. For
+ example, "object" is out, because it may have accessor properties on it.
+ """
+ if type.nullable():
+ # Converting null to JSON is always OK.
+ return CGDictionary.typeSafeToJSONify(type.inner)
+
+ if type.isSequence():
+ # Sequences are arrays we create ourselves, with no holes. They
+ # should be safe if their contents are safe, as long as we suppress
+ # invocation of .toJSON on objects.
+ return CGDictionary.typeSafeToJSONify(type.inner)
+
+ if type.isUnion():
+ # OK if everything in it is ok.
+ return all(CGDictionary.typeSafeToJSONify(t)
+ for t in type.flatMemberTypes)
+
+ if type.isDictionary():
+ # OK if the dictionary is OK
+ return CGDictionary.dictionarySafeToJSONify(type.inner)
+
+ if type.isString() or type.isEnum():
+ # Strings are always OK.
+ return True
+
+ if type.isPrimitive():
+ # Primitives (numbers and booleans) are ok, as long as
+ # they're not unrestricted float/double.
+ return not type.isFloat() or not type.isUnrestricted()
+
+ return False
+
+ @staticmethod
+ def dictionarySafeToJSONify(dictionary):
+ # The dictionary itself is OK, so we're good if all our types are.
+ return all(CGDictionary.typeSafeToJSONify(m.type)
+ for m in dictionary.members)
+
+
+class CGRegisterWorkerBindings(CGAbstractMethod):
+ def __init__(self, config):
+ CGAbstractMethod.__init__(self, None, 'RegisterWorkerBindings', 'bool',
+ [Argument('JSContext*', 'aCx'),
+ Argument('JS::Handle<JSObject*>', 'aObj')])
+ self.config = config
+
+ def definition_body(self):
+ descriptors = self.config.getDescriptors(hasInterfaceObject=True,
+ isExposedInAnyWorker=True,
+ register=True)
+ conditions = []
+ for desc in descriptors:
+ bindingNS = toBindingNamespace(desc.name)
+ condition = "!%s::GetConstructorObject(aCx)" % bindingNS
+ if desc.isExposedConditionally():
+ condition = (
+ "%s::ConstructorEnabled(aCx, aObj) && " % bindingNS
+ + condition)
+ conditions.append(condition)
+ lines = [CGIfWrapper(CGGeneric("return false;\n"), condition) for
+ condition in conditions]
+ lines.append(CGGeneric("return true;\n"))
+ return CGList(lines, "\n").define()
+
+class CGRegisterWorkerDebuggerBindings(CGAbstractMethod):
+ def __init__(self, config):
+ CGAbstractMethod.__init__(self, None, 'RegisterWorkerDebuggerBindings', 'bool',
+ [Argument('JSContext*', 'aCx'),
+ Argument('JS::Handle<JSObject*>', 'aObj')])
+ self.config = config
+
+ def definition_body(self):
+ descriptors = self.config.getDescriptors(hasInterfaceObject=True,
+ isExposedInWorkerDebugger=True,
+ register=True)
+ conditions = []
+ for desc in descriptors:
+ bindingNS = toBindingNamespace(desc.name)
+ condition = "!%s::GetConstructorObject(aCx)" % bindingNS
+ if desc.isExposedConditionally():
+ condition = (
+ "%s::ConstructorEnabled(aCx, aObj) && " % bindingNS
+ + condition)
+ conditions.append(condition)
+ lines = [CGIfWrapper(CGGeneric("return false;\n"), condition) for
+ condition in conditions]
+ lines.append(CGGeneric("return true;\n"))
+ return CGList(lines, "\n").define()
+
+class CGRegisterWorkletBindings(CGAbstractMethod):
+ def __init__(self, config):
+ CGAbstractMethod.__init__(self, None, 'RegisterWorkletBindings', 'bool',
+ [Argument('JSContext*', 'aCx'),
+ Argument('JS::Handle<JSObject*>', 'aObj')])
+ self.config = config
+
+ def definition_body(self):
+ descriptors = self.config.getDescriptors(hasInterfaceObject=True,
+ isExposedInAnyWorklet=True,
+ register=True)
+ conditions = []
+ for desc in descriptors:
+ bindingNS = toBindingNamespace(desc.name)
+ condition = "!%s::GetConstructorObject(aCx)" % bindingNS
+ if desc.isExposedConditionally():
+ condition = (
+ "%s::ConstructorEnabled(aCx, aObj) && " % bindingNS
+ + condition)
+ conditions.append(condition)
+ lines = [CGIfWrapper(CGGeneric("return false;\n"), condition) for
+ condition in conditions]
+ lines.append(CGGeneric("return true;\n"))
+ return CGList(lines, "\n").define()
+
+class CGResolveSystemBinding(CGAbstractMethod):
+ def __init__(self, config):
+ CGAbstractMethod.__init__(self, None, 'ResolveSystemBinding', 'bool',
+ [Argument('JSContext*', 'aCx'),
+ Argument('JS::Handle<JSObject*>', 'aObj'),
+ Argument('JS::Handle<jsid>', 'aId'),
+ Argument('bool*', 'aResolvedp')])
+ self.config = config
+
+ def definition_body(self):
+ descriptors = self.config.getDescriptors(hasInterfaceObject=True,
+ isExposedInSystemGlobals=True,
+ register=True)
+
+ def descNameToId(name):
+ return "s%s_id" % name
+ jsidNames = [descNameToId(desc.name) for desc in descriptors]
+ jsidDecls = CGList(CGGeneric("static jsid %s;\n" % name)
+ for name in jsidNames)
+
+ jsidInits = CGList(
+ (CGIfWrapper(
+ CGGeneric("return false;\n"),
+ '!AtomizeAndPinJSString(aCx, %s, "%s")' %
+ (descNameToId(desc.name), desc.interface.identifier.name))
+ for desc in descriptors),
+ "\n")
+ jsidInits.append(CGGeneric("idsInited = true;\n"))
+ jsidInits = CGIfWrapper(jsidInits, "!idsInited")
+ jsidInits = CGList([CGGeneric("static bool idsInited = false;\n"),
+ jsidInits])
+
+ definitions = CGList([], "\n")
+ for desc in descriptors:
+ bindingNS = toBindingNamespace(desc.name)
+ defineCode = "!%s::GetConstructorObject(aCx)" % bindingNS
+ defineCode = CGIfWrapper(CGGeneric("return false;\n"), defineCode)
+ defineCode = CGList([defineCode,
+ CGGeneric("*aResolvedp = true;\n")])
+
+ condition = "JSID_IS_VOID(aId) || aId == %s" % descNameToId(desc.name)
+ if desc.isExposedConditionally():
+ condition = "(%s) && %s::ConstructorEnabled(aCx, aObj)" % (condition, bindingNS)
+
+ definitions.append(CGIfWrapper(defineCode, condition))
+
+ return CGList([CGGeneric("MOZ_ASSERT(NS_IsMainThread());\n"),
+ jsidDecls,
+ jsidInits,
+ definitions,
+ CGGeneric("return true;\n")],
+ "\n").define()
+
+
+def getGlobalNames(config):
+ names = []
+ for desc in config.getDescriptors(registersGlobalNamesOnWindow=True):
+ names.append((desc.name, desc))
+ names.extend((n.identifier.name, desc) for n in desc.interface.namedConstructors)
+ return names
+
+class CGGlobalNamesString(CGGeneric):
+ def __init__(self, config):
+ globalNames = getGlobalNames(config)
+ currentOffset = 0
+ strings = []
+ for (name, _) in globalNames:
+ strings.append('/* %i */ "%s\\0"' % (currentOffset, name))
+ currentOffset += len(name) + 1 # Add trailing null.
+ define = fill("""
+ const uint32_t WebIDLGlobalNameHash::sCount = ${count};
+
+ const char WebIDLGlobalNameHash::sNames[] =
+ $*{strings}
+
+ """,
+ count=len(globalNames),
+ strings="\n".join(strings) + ";\n")
+
+ CGGeneric.__init__(self, define=define)
+
+
+class CGRegisterGlobalNames(CGAbstractMethod):
+ def __init__(self, config):
+ CGAbstractMethod.__init__(self, None, 'RegisterWebIDLGlobalNames',
+ 'void', [])
+ self.config = config
+
+ def definition_body(self):
+ def getCheck(desc):
+ if not desc.isExposedConditionally():
+ return "nullptr"
+ return "%sBinding::ConstructorEnabled" % desc.name
+
+ define = ""
+ currentOffset = 0
+ for (name, desc) in getGlobalNames(self.config):
+ length = len(name)
+ define += "WebIDLGlobalNameHash::Register(%i, %i, %sBinding::DefineDOMInterface, %s);\n" % (currentOffset, length, desc.name, getCheck(desc))
+ currentOffset += length + 1 # Add trailing null.
+ return define
+
+
+def dependencySortObjects(objects, dependencyGetter, nameGetter):
+ """
+ Sort IDL objects with dependencies on each other such that if A
+ depends on B then B will come before A. This is needed for
+ declaring C++ classes in the right order, for example. Objects
+ that have no dependencies are just sorted by name.
+
+ objects should be something that can produce a set of objects
+ (e.g. a set, iterator, list, etc).
+
+ dependencyGetter is something that, given an object, should return
+ the set of objects it depends on.
+ """
+ # XXXbz this will fail if we have two webidl files F1 and F2 such that F1
+ # declares an object which depends on an object in F2, and F2 declares an
+ # object (possibly a different one!) that depends on an object in F1. The
+ # good news is that I expect this to never happen.
+ sortedObjects = []
+ objects = set(objects)
+ while len(objects) != 0:
+ # Find the dictionaries that don't depend on anything else
+ # anymore and move them over.
+ toMove = [o for o in objects if
+ len(dependencyGetter(o) & objects) == 0]
+ if len(toMove) == 0:
+ raise TypeError("Loop in dependency graph\n" +
+ "\n".join(o.location for o in objects))
+ objects = objects - set(toMove)
+ sortedObjects.extend(sorted(toMove, key=nameGetter))
+ return sortedObjects
+
+
+class ForwardDeclarationBuilder:
+ """
+ Create a canonical representation of a set of namespaced forward
+ declarations.
+ """
+ def __init__(self):
+ """
+ The set of declarations is represented as a tree of nested namespaces.
+ Each tree node has a set of declarations |decls| and a dict |children|.
+ Each declaration is a pair consisting of the class name and a boolean
+ that is true iff the class is really a struct. |children| maps the
+ names of inner namespaces to the declarations in that namespace.
+ """
+ self.decls = set()
+ self.children = {}
+
+ def _ensureNonTemplateType(self, type):
+ if "<" in type:
+ # This is a templated type. We don't really know how to
+ # forward-declare those, and trying to do it naively is not going to
+ # go well (e.g. we may have :: characters inside the type we're
+ # templated on!). Just bail out.
+ raise TypeError("Attempt to use ForwardDeclarationBuilder on "
+ "templated type %s. We don't know how to do that "
+ "yet." % type)
+
+ def _listAdd(self, namespaces, name, isStruct=False):
+ """
+ Add a forward declaration, where |namespaces| is a list of namespaces.
+ |name| should not contain any other namespaces.
+ """
+ if namespaces:
+ child = self.children.setdefault(namespaces[0], ForwardDeclarationBuilder())
+ child._listAdd(namespaces[1:], name, isStruct)
+ else:
+ assert '::' not in name
+ self.decls.add((name, isStruct))
+
+ def addInMozillaDom(self, name, isStruct=False):
+ """
+ Add a forward declaration to the mozilla::dom:: namespace. |name| should not
+ contain any other namespaces.
+ """
+ self._ensureNonTemplateType(name);
+ self._listAdd(["mozilla", "dom"], name, isStruct)
+
+ def add(self, nativeType, isStruct=False):
+ """
+ Add a forward declaration, where |nativeType| is a string containing
+ the type and its namespaces, in the usual C++ way.
+ """
+ self._ensureNonTemplateType(nativeType);
+ components = nativeType.split('::')
+ self._listAdd(components[:-1], components[-1], isStruct)
+
+ def _build(self, atTopLevel):
+ """
+ Return a codegenerator for the forward declarations.
+ """
+ decls = []
+ if self.decls:
+ decls.append(CGList([CGClassForwardDeclare(cname, isStruct)
+ for cname, isStruct in sorted(self.decls)]))
+ for namespace, child in sorted(self.children.iteritems()):
+ decls.append(CGNamespace(namespace, child._build(atTopLevel=False), declareOnly=True))
+
+ cg = CGList(decls, "\n")
+ if not atTopLevel and len(decls) + len(self.decls) > 1:
+ cg = CGWrapper(cg, pre='\n', post='\n')
+ return cg
+
+ def build(self):
+ return self._build(atTopLevel=True)
+
+ def forwardDeclareForType(self, t, config):
+ t = t.unroll()
+ if t.isGeckoInterface():
+ name = t.inner.identifier.name
+ try:
+ desc = config.getDescriptor(name)
+ self.add(desc.nativeType)
+ except NoSuchDescriptorError:
+ pass
+
+ # Note: Spidermonkey interfaces are typedefs, so can't be
+ # forward-declared
+ elif t.isCallback():
+ self.addInMozillaDom(t.callback.identifier.name)
+ elif t.isDictionary():
+ self.addInMozillaDom(t.inner.identifier.name, isStruct=True)
+ elif t.isCallbackInterface():
+ self.addInMozillaDom(t.inner.identifier.name)
+ elif t.isUnion():
+ # Forward declare both the owning and non-owning version,
+ # since we don't know which one we might want
+ self.addInMozillaDom(CGUnionStruct.unionTypeName(t, False))
+ self.addInMozillaDom(CGUnionStruct.unionTypeName(t, True))
+ elif t.isMozMap():
+ self.forwardDeclareForType(t.inner, config)
+ # Don't need to do anything for void, primitive, string, any or object.
+ # There may be some other cases we are missing.
+
+
+class CGForwardDeclarations(CGWrapper):
+ """
+ Code generate the forward declarations for a header file.
+ additionalDeclarations is a list of tuples containing a classname and a
+ boolean. If the boolean is true we will declare a struct, otherwise we'll
+ declare a class.
+ """
+ def __init__(self, config, descriptors, callbacks,
+ dictionaries, callbackInterfaces, additionalDeclarations=[]):
+ builder = ForwardDeclarationBuilder()
+
+ # Needed for at least Wrap.
+ for d in descriptors:
+ # If this is a generated iterator interface, we only create these
+ # in the generated bindings, and don't need to forward declare.
+ if d.interface.isIteratorInterface():
+ continue
+ builder.add(d.nativeType)
+ # If we're an interface and we have a maplike/setlike declaration,
+ # we'll have helper functions exposed to the native side of our
+ # bindings, which will need to show up in the header. If either of
+ # our key/value types are interfaces, they'll be passed as
+ # arguments to helper functions, and they'll need to be forward
+ # declared in the header.
+ if d.interface.maplikeOrSetlikeOrIterable:
+ if d.interface.maplikeOrSetlikeOrIterable.hasKeyType():
+ builder.forwardDeclareForType(d.interface.maplikeOrSetlikeOrIterable.keyType,
+ config)
+ if d.interface.maplikeOrSetlikeOrIterable.hasValueType():
+ builder.forwardDeclareForType(d.interface.maplikeOrSetlikeOrIterable.valueType,
+ config)
+
+ # We just about always need NativePropertyHooks
+ builder.addInMozillaDom("NativePropertyHooks", isStruct=True)
+ builder.addInMozillaDom("ProtoAndIfaceCache")
+ # Add the atoms cache type, even if we don't need it.
+ for d in descriptors:
+ # Iterators have native types that are template classes, so
+ # creating an 'Atoms' cache type doesn't work for them, and is one
+ # of the cases where we don't need it anyways.
+ if d.interface.isIteratorInterface():
+ continue
+ builder.add(d.nativeType + "Atoms", isStruct=True)
+
+ for callback in callbacks:
+ builder.addInMozillaDom(callback.identifier.name)
+ for t in getTypesFromCallback(callback):
+ builder.forwardDeclareForType(t, config)
+
+ for d in callbackInterfaces:
+ builder.add(d.nativeType)
+ builder.add(d.nativeType + "Atoms", isStruct=True)
+ for t in getTypesFromDescriptor(d):
+ builder.forwardDeclareForType(t, config)
+
+ for d in dictionaries:
+ if len(d.members) > 0:
+ builder.addInMozillaDom(d.identifier.name + "Atoms", isStruct=True)
+ for t in getTypesFromDictionary(d):
+ builder.forwardDeclareForType(t, config)
+
+ for className, isStruct in additionalDeclarations:
+ builder.add(className, isStruct=isStruct)
+
+ CGWrapper.__init__(self, builder.build())
+
+
+class CGBindingRoot(CGThing):
+ """
+ Root codegen class for binding generation. Instantiate the class, and call
+ declare or define to generate header or cpp code (respectively).
+ """
+ def __init__(self, config, prefix, webIDLFile):
+ bindingHeaders = dict.fromkeys((
+ 'mozilla/dom/NonRefcountedDOMObject.h',
+ ),
+ True)
+ bindingDeclareHeaders = dict.fromkeys((
+ 'mozilla/dom/BindingDeclarations.h',
+ 'mozilla/dom/Nullable.h',
+ 'mozilla/ErrorResult.h',
+ ),
+ True)
+
+ descriptors = config.getDescriptors(webIDLFile=webIDLFile,
+ hasInterfaceOrInterfacePrototypeObject=True)
+
+ unionTypes = UnionsForFile(config, webIDLFile)
+
+ (unionHeaders, unionImplheaders, unionDeclarations, traverseMethods,
+ unlinkMethods, unionStructs) = UnionTypes(unionTypes, config)
+
+ bindingDeclareHeaders.update(dict.fromkeys(unionHeaders, True))
+ bindingHeaders.update(dict.fromkeys(unionImplheaders, True))
+ bindingDeclareHeaders["mozilla/dom/UnionMember.h"] = len(unionStructs) > 0
+ bindingDeclareHeaders["mozilla/dom/FakeString.h"] = len(unionStructs) > 0
+ # BindingUtils.h is only needed for SetToObject.
+ # If it stops being inlined or stops calling CallerSubsumes
+ # both this bit and the bit in UnionTypes can be removed.
+ bindingDeclareHeaders["mozilla/dom/BindingUtils.h"] = any(d.isObject() for t in unionTypes
+ for d in t.flatMemberTypes)
+ bindingDeclareHeaders["mozilla/dom/IterableIterator.h"] = any(d.interface.isIteratorInterface() or
+ d.interface.isIterable() for d in descriptors)
+
+ def descriptorHasCrossOriginProperties(desc):
+ def hasCrossOriginProperty(m):
+ props = memberProperties(m, desc)
+ return (props.isCrossOriginMethod or
+ props.isCrossOriginGetter or
+ props.isCrossOriginSetter)
+
+ return any(hasCrossOriginProperty(m) for m in desc.interface.members)
+
+ bindingDeclareHeaders["jsapi.h"] = any(descriptorHasCrossOriginProperties(d) for d in descriptors)
+ bindingDeclareHeaders["jspubtd.h"] = not bindingDeclareHeaders["jsapi.h"]
+ bindingDeclareHeaders["js/RootingAPI.h"] = not bindingDeclareHeaders["jsapi.h"]
+
+ def descriptorRequiresPreferences(desc):
+ iface = desc.interface
+ return any(m.getExtendedAttribute("Pref") for m in iface.members + [iface])
+
+ def descriptorDeprecated(desc):
+ iface = desc.interface
+ return any(m.getExtendedAttribute("Deprecated") for m in iface.members + [iface])
+
+ bindingHeaders["nsIDocument.h"] = any(
+ descriptorDeprecated(d) for d in descriptors)
+ bindingHeaders["mozilla/Preferences.h"] = any(
+ descriptorRequiresPreferences(d) for d in descriptors)
+ bindingHeaders["mozilla/dom/DOMJSProxyHandler.h"] = any(
+ d.concrete and d.proxy for d in descriptors)
+
+ def descriptorHasChromeOnly(desc):
+ ctor = desc.interface.ctor()
+
+ return (any(isChromeOnly(a) or needsContainsHack(a) or
+ needsCallerType(a)
+ for a in desc.interface.members) or
+ desc.interface.getExtendedAttribute("ChromeOnly") is not None or
+ # JS-implemented interfaces with an interface object get a
+ # chromeonly _create method. And interfaces with an
+ # interface object might have a ChromeOnly constructor.
+ (desc.interface.hasInterfaceObject() and
+ (desc.interface.isJSImplemented() or
+ (ctor and isChromeOnly(ctor)))) or
+ # JS-implemented interfaces with clearable cached
+ # attrs have chromeonly _clearFoo methods.
+ (desc.interface.isJSImplemented() and
+ any(clearableCachedAttrs(desc))))
+
+ # XXXkhuey ugly hack but this is going away soon.
+ bindingHeaders['xpcprivate.h'] = webIDLFile.endswith("EventTarget.webidl")
+
+ hasThreadChecks = any(d.hasThreadChecks() for d in descriptors)
+ bindingHeaders["nsThreadUtils.h"] = hasThreadChecks
+
+ dictionaries = config.getDictionaries(webIDLFile)
+
+ def dictionaryHasChromeOnly(dictionary):
+ while dictionary:
+ if (any(isChromeOnly(m) for m in dictionary.members)):
+ return True
+ dictionary = dictionary.parent
+ return False
+
+ bindingHeaders["nsContentUtils.h"] = (
+ any(descriptorHasChromeOnly(d) for d in descriptors) or
+ any(dictionaryHasChromeOnly(d) for d in dictionaries))
+ hasNonEmptyDictionaries = any(
+ len(dict.members) > 0 for dict in dictionaries)
+ callbacks = config.getCallbacks(webIDLFile)
+ callbackDescriptors = config.getDescriptors(webIDLFile=webIDLFile,
+ isCallback=True)
+ jsImplemented = config.getDescriptors(webIDLFile=webIDLFile,
+ isJSImplemented=True)
+ bindingDeclareHeaders["nsWeakReference.h"] = jsImplemented
+ bindingHeaders["nsIGlobalObject.h"] = jsImplemented
+ bindingHeaders["AtomList.h"] = hasNonEmptyDictionaries or jsImplemented or callbackDescriptors
+
+ def descriptorClearsPropsInSlots(descriptor):
+ if not descriptor.wrapperCache:
+ return False
+ return any(m.isAttr() and m.getExtendedAttribute("StoreInSlot")
+ for m in descriptor.interface.members)
+ bindingHeaders["nsJSUtils.h"] = any(descriptorClearsPropsInSlots(d) for d in descriptors)
+
+ # Do codegen for all the enums
+ enums = config.getEnums(webIDLFile)
+ cgthings = [CGEnum(e) for e in enums]
+
+ hasCode = (descriptors or callbackDescriptors or dictionaries or
+ callbacks)
+ bindingHeaders["mozilla/dom/BindingUtils.h"] = hasCode
+ bindingHeaders["mozilla/OwningNonNull.h"] = hasCode
+ bindingHeaders["mozilla/dom/BindingDeclarations.h"] = (
+ not hasCode and enums)
+
+ bindingHeaders["WrapperFactory.h"] = descriptors
+ bindingHeaders["mozilla/dom/DOMJSClass.h"] = descriptors
+ bindingHeaders["mozilla/dom/ScriptSettings.h"] = dictionaries # AutoJSAPI
+ # Ensure we see our enums in the generated .cpp file, for the ToJSValue
+ # method body. Also ensure that we see jsapi.h.
+ if enums:
+ bindingHeaders[CGHeaders.getDeclarationFilename(enums[0])] = True
+ bindingHeaders["jsapi.h"] = True
+
+ # For things that have [UseCounter]
+ def descriptorRequiresTelemetry(desc):
+ iface = desc.interface
+ return any(m.getExtendedAttribute("UseCounter") for m in iface.members)
+ bindingHeaders["mozilla/UseCounter.h"] = any(
+ descriptorRequiresTelemetry(d) for d in descriptors)
+ bindingHeaders["mozilla/dom/SimpleGlobalObject.h"] = any(
+ CGDictionary.dictionarySafeToJSONify(d) for d in dictionaries)
+ bindingHeaders["XrayWrapper.h"] = any(
+ d.wantsXrays and d.wantsXrayExpandoClass for d in descriptors)
+ bindingHeaders["mozilla/dom/XrayExpandoClass.h"] = any(
+ d.wantsXrays for d in descriptors)
+
+ cgthings.extend(traverseMethods)
+ cgthings.extend(unlinkMethods)
+
+ # Do codegen for all the dictionaries. We have to be a bit careful
+ # here, because we have to generate these in order from least derived
+ # to most derived so that class inheritance works out. We also have to
+ # generate members before the dictionary that contains them.
+
+ def getDependenciesFromType(type):
+ if type.isDictionary():
+ return set([type.unroll().inner])
+ if type.isSequence():
+ return getDependenciesFromType(type.unroll())
+ if type.isUnion():
+ return set([type.unroll()])
+ return set()
+
+ def getDependencies(unionTypeOrDictionary):
+ if isinstance(unionTypeOrDictionary, IDLDictionary):
+ deps = set()
+ if unionTypeOrDictionary.parent:
+ deps.add(unionTypeOrDictionary.parent)
+ for member in unionTypeOrDictionary.members:
+ deps |= getDependenciesFromType(member.type)
+ return deps
+
+ assert unionTypeOrDictionary.isType() and unionTypeOrDictionary.isUnion()
+ deps = set()
+ for member in unionTypeOrDictionary.flatMemberTypes:
+ deps |= getDependenciesFromType(member)
+ return deps
+
+ def getName(unionTypeOrDictionary):
+ if isinstance(unionTypeOrDictionary, IDLDictionary):
+ return unionTypeOrDictionary.identifier.name
+
+ assert unionTypeOrDictionary.isType() and unionTypeOrDictionary.isUnion()
+ return unionTypeOrDictionary.name
+
+ for t in dependencySortObjects(dictionaries + unionStructs, getDependencies, getName):
+ if t.isDictionary():
+ cgthings.append(CGDictionary(t, config))
+ else:
+ assert t.isUnion()
+ cgthings.append(CGUnionStruct(t, config))
+ cgthings.append(CGUnionStruct(t, config, True))
+
+ # Do codegen for all the callbacks.
+ cgthings.extend(CGCallbackFunction(c, config) for c in callbacks)
+
+ cgthings.extend([CGNamespace('binding_detail', CGFastCallback(c))
+ for c in callbacks])
+
+ # Do codegen for all the descriptors
+ cgthings.extend([CGDescriptor(x) for x in descriptors])
+
+ # Do codegen for all the callback interfaces.
+ cgthings.extend([CGCallbackInterface(x) for x in callbackDescriptors])
+
+ cgthings.extend([CGNamespace('binding_detail',
+ CGFastCallback(x.interface))
+ for x in callbackDescriptors])
+
+ # Do codegen for JS implemented classes
+ def getParentDescriptor(desc):
+ if not desc.interface.parent:
+ return set()
+ return {desc.getDescriptor(desc.interface.parent.identifier.name)}
+ for x in dependencySortObjects(jsImplemented, getParentDescriptor,
+ lambda d: d.interface.identifier.name):
+ cgthings.append(CGCallbackInterface(x, typedArraysAreStructs=True))
+ cgthings.append(CGJSImplClass(x))
+
+ # And make sure we have the right number of newlines at the end
+ curr = CGWrapper(CGList(cgthings, "\n\n"), post="\n\n")
+
+ # Wrap all of that in our namespaces.
+ curr = CGNamespace.build(['mozilla', 'dom'],
+ CGWrapper(curr, pre="\n"))
+
+ curr = CGList([CGForwardDeclarations(config, descriptors,
+ callbacks,
+ dictionaries,
+ callbackDescriptors + jsImplemented,
+ additionalDeclarations=unionDeclarations),
+ curr],
+ "\n")
+
+ # Add header includes.
+ bindingHeaders = [header
+ for header, include in bindingHeaders.iteritems()
+ if include]
+ bindingDeclareHeaders = [header
+ for header, include in bindingDeclareHeaders.iteritems()
+ if include]
+
+ curr = CGHeaders(descriptors,
+ dictionaries,
+ callbacks,
+ callbackDescriptors,
+ bindingDeclareHeaders,
+ bindingHeaders,
+ prefix,
+ curr,
+ config,
+ jsImplemented)
+
+ # Add include guards.
+ curr = CGIncludeGuard(prefix, curr)
+
+ # Add the auto-generated comment.
+ curr = CGWrapper(
+ curr,
+ pre=(AUTOGENERATED_WITH_SOURCE_WARNING_COMMENT %
+ os.path.basename(webIDLFile)))
+
+ # Store the final result.
+ self.root = curr
+
+ def declare(self):
+ return stripTrailingWhitespace(self.root.declare())
+
+ def define(self):
+ return stripTrailingWhitespace(self.root.define())
+
+ def deps(self):
+ return self.root.deps()
+
+
+class CGNativeMember(ClassMethod):
+ def __init__(self, descriptorProvider, member, name, signature, extendedAttrs,
+ breakAfter=True, passJSBitsAsNeeded=True, visibility="public",
+ typedArraysAreStructs=True, variadicIsSequence=False,
+ resultNotAddRefed=False,
+ virtual=False,
+ override=False):
+ """
+ If typedArraysAreStructs is false, typed arrays will be passed as
+ JS::Handle<JSObject*>. If it's true they will be passed as one of the
+ dom::TypedArray subclasses.
+
+ If passJSBitsAsNeeded is false, we don't automatically pass in a
+ JSContext* or a JSObject* based on the return and argument types. We
+ can still pass it based on 'implicitJSContext' annotations.
+ """
+ self.descriptorProvider = descriptorProvider
+ self.member = member
+ self.extendedAttrs = extendedAttrs
+ self.resultAlreadyAddRefed = not resultNotAddRefed
+ self.passJSBitsAsNeeded = passJSBitsAsNeeded
+ self.typedArraysAreStructs = typedArraysAreStructs
+ self.variadicIsSequence = variadicIsSequence
+ breakAfterSelf = "\n" if breakAfter else ""
+ ClassMethod.__init__(self, name,
+ self.getReturnType(signature[0], False),
+ self.getArgs(signature[0], signature[1]),
+ static=member.isStatic(),
+ # Mark our getters, which are attrs that
+ # have a non-void return type, as const.
+ const=(not member.isStatic() and member.isAttr() and
+ not signature[0].isVoid()),
+ breakAfterReturnDecl=" ",
+ breakAfterSelf=breakAfterSelf,
+ visibility=visibility,
+ virtual=virtual,
+ override=override)
+
+ def getReturnType(self, type, isMember):
+ return self.getRetvalInfo(type, isMember)[0]
+
+ def getRetvalInfo(self, type, isMember):
+ """
+ Returns a tuple:
+
+ The first element is the type declaration for the retval
+
+ The second element is a default value that can be used on error returns.
+ For cases whose behavior depends on isMember, the second element will be
+ None if isMember is true.
+
+ The third element is a template for actually returning a value stored in
+ "${declName}" and "${holderName}". This means actually returning it if
+ we're not outparam, else assigning to the "retval" outparam. If
+ isMember is true, this can be None, since in that case the caller will
+ never examine this value.
+ """
+ if type.isVoid():
+ return "void", "", ""
+ if type.isPrimitive() and type.tag() in builtinNames:
+ result = CGGeneric(builtinNames[type.tag()])
+ defaultReturnArg = "0"
+ if type.nullable():
+ result = CGTemplatedType("Nullable", result)
+ defaultReturnArg = ""
+ return (result.define(),
+ "%s(%s)" % (result.define(), defaultReturnArg),
+ "return ${declName};\n")
+ if type.isDOMString() or type.isUSVString():
+ if isMember:
+ # No need for a third element in the isMember case
+ return "nsString", None, None
+ # Outparam
+ return "void", "", "aRetVal = ${declName};\n"
+ if type.isByteString():
+ if isMember:
+ # No need for a third element in the isMember case
+ return "nsCString", None, None
+ # Outparam
+ return "void", "", "aRetVal = ${declName};\n"
+ if type.isEnum():
+ enumName = type.unroll().inner.identifier.name
+ if type.nullable():
+ enumName = CGTemplatedType("Nullable",
+ CGGeneric(enumName)).define()
+ defaultValue = "%s()" % enumName
+ else:
+ defaultValue = "%s(0)" % enumName
+ return enumName, defaultValue, "return ${declName};\n"
+ if type.isGeckoInterface():
+ iface = type.unroll().inner
+ result = CGGeneric(self.descriptorProvider.getDescriptor(
+ iface.identifier.name).prettyNativeType)
+ if self.resultAlreadyAddRefed:
+ if isMember:
+ holder = "RefPtr"
+ else:
+ holder = "already_AddRefed"
+ if memberReturnsNewObject(self.member) or isMember:
+ warning = ""
+ else:
+ warning = "// Return a raw pointer here to avoid refcounting, but make sure it's safe (the object should be kept alive by the callee).\n"
+ result = CGWrapper(result,
+ pre=("%s%s<" % (warning, holder)),
+ post=">")
+ else:
+ result = CGWrapper(result, post="*")
+ # Since we always force an owning type for callback return values,
+ # our ${declName} is an OwningNonNull or RefPtr. So we can just
+ # .forget() to get our already_AddRefed.
+ return result.define(), "nullptr", "return ${declName}.forget();\n"
+ if type.isCallback():
+ return ("already_AddRefed<%s>" % type.unroll().callback.identifier.name,
+ "nullptr", "return ${declName}.forget();\n")
+ if type.isAny():
+ if isMember:
+ # No need for a third element in the isMember case
+ return "JS::Value", None, None
+ # Outparam
+ return "void", "", "aRetVal.set(${declName});\n"
+
+ if type.isObject():
+ if isMember:
+ # No need for a third element in the isMember case
+ return "JSObject*", None, None
+ return "void", "", "aRetVal.set(${declName});\n"
+ if type.isSpiderMonkeyInterface():
+ if isMember:
+ # No need for a third element in the isMember case
+ return "JSObject*", None, None
+ if type.nullable():
+ returnCode = "${declName}.IsNull() ? nullptr : ${declName}.Value().Obj()"
+ else:
+ returnCode = "${declName}.Obj()"
+ return "void", "", "aRetVal.set(%s);\n" % returnCode
+ if type.isSequence():
+ # If we want to handle sequence-of-sequences return values, we're
+ # going to need to fix example codegen to not produce nsTArray<void>
+ # for the relevant argument...
+ assert not isMember
+ # Outparam.
+ if type.nullable():
+ returnCode = dedent("""
+ if (${declName}.IsNull()) {
+ aRetVal.SetNull();
+ } else {
+ aRetVal.SetValue().SwapElements(${declName}.Value());
+ }
+ """)
+ else:
+ returnCode = "aRetVal.SwapElements(${declName});\n"
+ return "void", "", returnCode
+ if type.isMozMap():
+ # If we want to handle MozMap-of-MozMap return values, we're
+ # going to need to fix example codegen to not produce MozMap<void>
+ # for the relevant argument...
+ assert not isMember
+ # In this case we convert directly into our outparam to start with
+ return "void", "", ""
+ if type.isDate():
+ result = CGGeneric("Date")
+ if type.nullable():
+ result = CGTemplatedType("Nullable", result)
+ return (result.define(), "%s()" % result.define(),
+ "return ${declName};\n")
+ if type.isDictionary():
+ if isMember:
+ # Only the first member of the tuple matters here, but return
+ # bogus values for the others in case someone decides to use
+ # them.
+ return CGDictionary.makeDictionaryName(type.inner), None, None
+ # In this case we convert directly into our outparam to start with
+ return "void", "", ""
+ if type.isUnion():
+ if isMember:
+ # Only the first member of the tuple matters here, but return
+ # bogus values for the others in case someone decides to use
+ # them.
+ return CGUnionStruct.unionTypeDecl(type, True), None, None
+ # In this case we convert directly into our outparam to start with
+ return "void", "", ""
+
+ raise TypeError("Don't know how to declare return value for %s" %
+ type)
+
+ def getArgs(self, returnType, argList):
+ args = [self.getArg(arg) for arg in argList]
+ # Now the outparams
+ if returnType.isDOMString() or returnType.isUSVString():
+ args.append(Argument("nsString&", "aRetVal"))
+ elif returnType.isByteString():
+ args.append(Argument("nsCString&", "aRetVal"))
+ elif returnType.isSequence():
+ nullable = returnType.nullable()
+ if nullable:
+ returnType = returnType.inner
+ # And now the actual underlying type
+ elementDecl = self.getReturnType(returnType.inner, True)
+ type = CGTemplatedType("nsTArray", CGGeneric(elementDecl))
+ if nullable:
+ type = CGTemplatedType("Nullable", type)
+ args.append(Argument("%s&" % type.define(), "aRetVal"))
+ elif returnType.isMozMap():
+ nullable = returnType.nullable()
+ if nullable:
+ returnType = returnType.inner
+ # And now the actual underlying type
+ elementDecl = self.getReturnType(returnType.inner, True)
+ type = CGTemplatedType("MozMap", CGGeneric(elementDecl))
+ if nullable:
+ type = CGTemplatedType("Nullable", type)
+ args.append(Argument("%s&" % type.define(), "aRetVal"))
+ elif returnType.isDictionary():
+ nullable = returnType.nullable()
+ if nullable:
+ returnType = returnType.inner
+ dictType = CGGeneric(CGDictionary.makeDictionaryName(returnType.inner))
+ if nullable:
+ dictType = CGTemplatedType("Nullable", dictType)
+ args.append(Argument("%s&" % dictType.define(), "aRetVal"))
+ elif returnType.isUnion():
+ args.append(Argument("%s&" %
+ CGUnionStruct.unionTypeDecl(returnType, True),
+ "aRetVal"))
+ elif returnType.isAny():
+ args.append(Argument("JS::MutableHandle<JS::Value>", "aRetVal"))
+ elif returnType.isObject() or returnType.isSpiderMonkeyInterface():
+ args.append(Argument("JS::MutableHandle<JSObject*>", "aRetVal"))
+
+ # And the nsIPrincipal
+ if self.member.getExtendedAttribute('NeedsSubjectPrincipal'):
+ # Cheat and assume self.descriptorProvider is a descriptor
+ if self.descriptorProvider.interface.isExposedInAnyWorker():
+ args.append(Argument("Maybe<nsIPrincipal*>", "aSubjectPrincipal"))
+ else:
+ args.append(Argument("nsIPrincipal&", "aPrincipal"))
+ # And the caller type, if desired.
+ if needsCallerType(self.member):
+ args.append(Argument("CallerType", "aCallerType"))
+ # And the ErrorResult
+ if 'infallible' not in self.extendedAttrs:
+ # Use aRv so it won't conflict with local vars named "rv"
+ args.append(Argument("ErrorResult&", "aRv"))
+ # The legacycaller thisval
+ if self.member.isMethod() and self.member.isLegacycaller():
+ # If it has an identifier, we can't deal with it yet
+ assert self.member.isIdentifierLess()
+ args.insert(0, Argument("const JS::Value&", "aThisVal"))
+ # And jscontext bits.
+ if needCx(returnType, argList, self.extendedAttrs,
+ self.passJSBitsAsNeeded, self.member.isStatic()):
+ args.insert(0, Argument("JSContext*", "cx"))
+ if needScopeObject(returnType, argList, self.extendedAttrs,
+ self.descriptorProvider.wrapperCache,
+ self.passJSBitsAsNeeded,
+ self.member.getExtendedAttribute("StoreInSlot")):
+ args.insert(1, Argument("JS::Handle<JSObject*>", "obj"))
+ # And if we're static, a global
+ if self.member.isStatic():
+ args.insert(0, Argument("const GlobalObject&", "global"))
+ return args
+
+ def doGetArgType(self, type, optional, isMember):
+ """
+ The main work of getArgType. Returns a string type decl, whether this
+ is a const ref, as well as whether the type should be wrapped in
+ Nullable as needed.
+
+ isMember can be false or one of the strings "Sequence", "Variadic",
+ "MozMap"
+ """
+ if type.isSequence():
+ nullable = type.nullable()
+ if nullable:
+ type = type.inner
+ elementType = type.inner
+ argType = self.getArgType(elementType, False, "Sequence")[0]
+ decl = CGTemplatedType("Sequence", argType)
+ return decl.define(), True, True
+
+ if type.isMozMap():
+ nullable = type.nullable()
+ if nullable:
+ type = type.inner
+ elementType = type.inner
+ argType = self.getArgType(elementType, False, "MozMap")[0]
+ decl = CGTemplatedType("MozMap", argType)
+ return decl.define(), True, True
+
+ if type.isUnion():
+ # unionTypeDecl will handle nullable types, so return False for
+ # auto-wrapping in Nullable
+ return CGUnionStruct.unionTypeDecl(type, isMember), True, False
+
+ if type.isGeckoInterface() and not type.isCallbackInterface():
+ iface = type.unroll().inner
+ argIsPointer = type.nullable() or iface.isExternal()
+ forceOwningType = (iface.isCallback() or isMember or
+ iface.identifier.name == "Promise")
+ if argIsPointer:
+ if (optional or isMember) and forceOwningType:
+ typeDecl = "RefPtr<%s>"
+ else:
+ typeDecl = "%s*"
+ else:
+ if optional or isMember:
+ if forceOwningType:
+ typeDecl = "OwningNonNull<%s>"
+ else:
+ typeDecl = "NonNull<%s>"
+ else:
+ typeDecl = "%s&"
+ return ((typeDecl %
+ self.descriptorProvider.getDescriptor(iface.identifier.name).prettyNativeType),
+ False, False)
+
+ if type.isSpiderMonkeyInterface():
+ if not self.typedArraysAreStructs:
+ return "JS::Handle<JSObject*>", False, False
+
+ # Unroll for the name, in case we're nullable.
+ return type.unroll().name, True, True
+
+ if type.isDOMString() or type.isUSVString():
+ if isMember:
+ declType = "nsString"
+ else:
+ declType = "nsAString"
+ return declType, True, False
+
+ if type.isByteString():
+ declType = "nsCString"
+ return declType, True, False
+
+ if type.isEnum():
+ return type.unroll().inner.identifier.name, False, True
+
+ if type.isCallback() or type.isCallbackInterface():
+ forceOwningType = optional or isMember
+ if type.nullable():
+ if forceOwningType:
+ declType = "RefPtr<%s>"
+ else:
+ declType = "%s*"
+ else:
+ if forceOwningType:
+ declType = "OwningNonNull<%s>"
+ else:
+ declType = "%s&"
+ if type.isCallback():
+ name = type.unroll().callback.identifier.name
+ else:
+ name = type.unroll().inner.identifier.name
+ return declType % name, False, False
+
+ if type.isAny():
+ # Don't do the rooting stuff for variadics for now
+ if isMember:
+ declType = "JS::Value"
+ else:
+ declType = "JS::Handle<JS::Value>"
+ return declType, False, False
+
+ if type.isObject():
+ if isMember:
+ declType = "JSObject*"
+ else:
+ declType = "JS::Handle<JSObject*>"
+ return declType, False, False
+
+ if type.isDictionary():
+ typeName = CGDictionary.makeDictionaryName(type.inner)
+ return typeName, True, True
+
+ if type.isDate():
+ return "Date", False, True
+
+ assert type.isPrimitive()
+
+ return builtinNames[type.tag()], False, True
+
+ def getArgType(self, type, optional, isMember):
+ """
+ Get the type of an argument declaration. Returns the type CGThing, and
+ whether this should be a const ref.
+
+ isMember can be False, "Sequence", or "Variadic"
+ """
+ decl, ref, handleNullable = self.doGetArgType(type, optional, isMember)
+ decl = CGGeneric(decl)
+ if handleNullable and type.nullable():
+ decl = CGTemplatedType("Nullable", decl)
+ ref = True
+ if isMember == "Variadic":
+ arrayType = "Sequence" if self.variadicIsSequence else "nsTArray"
+ decl = CGTemplatedType(arrayType, decl)
+ ref = True
+ elif optional:
+ # Note: All variadic args claim to be optional, but we can just use
+ # empty arrays to represent them not being present.
+ decl = CGTemplatedType("Optional", decl)
+ ref = True
+ return (decl, ref)
+
+ def getArg(self, arg):
+ """
+ Get the full argument declaration for an argument
+ """
+ decl, ref = self.getArgType(arg.type, arg.canHaveMissingValue(),
+ "Variadic" if arg.variadic else False)
+ if ref:
+ decl = CGWrapper(decl, pre="const ", post="&")
+
+ return Argument(decl.define(), arg.identifier.name)
+
+ def arguments(self):
+ return self.member.signatures()[0][1]
+
+
+class CGExampleMethod(CGNativeMember):
+ def __init__(self, descriptor, method, signature, isConstructor, breakAfter=True):
+ CGNativeMember.__init__(self, descriptor, method,
+ CGSpecializedMethod.makeNativeName(descriptor,
+ method),
+ signature,
+ descriptor.getExtendedAttributes(method),
+ breakAfter=breakAfter,
+ variadicIsSequence=True)
+
+ def declare(self, cgClass):
+ assert self.member.isMethod()
+ # We skip declaring ourselves if this is a maplike/setlike/iterable
+ # method, because those get implemented automatically by the binding
+ # machinery, so the implementor of the interface doesn't have to worry
+ # about it.
+ if self.member.isMaplikeOrSetlikeOrIterableMethod():
+ return ''
+ return CGNativeMember.declare(self, cgClass);
+
+ def define(self, cgClass):
+ return ''
+
+
+class CGExampleGetter(CGNativeMember):
+ def __init__(self, descriptor, attr):
+ CGNativeMember.__init__(self, descriptor, attr,
+ CGSpecializedGetter.makeNativeName(descriptor,
+ attr),
+ (attr.type, []),
+ descriptor.getExtendedAttributes(attr,
+ getter=True))
+
+ def declare(self, cgClass):
+ assert self.member.isAttr()
+ # We skip declaring ourselves if this is a maplike/setlike attr (in
+ # practice, "size"), because those get implemented automatically by the
+ # binding machinery, so the implementor of the interface doesn't have to
+ # worry about it.
+ if self.member.isMaplikeOrSetlikeAttr():
+ return ''
+ return CGNativeMember.declare(self, cgClass);
+
+ def define(self, cgClass):
+ return ''
+
+
+class CGExampleSetter(CGNativeMember):
+ def __init__(self, descriptor, attr):
+ CGNativeMember.__init__(self, descriptor, attr,
+ CGSpecializedSetter.makeNativeName(descriptor,
+ attr),
+ (BuiltinTypes[IDLBuiltinType.Types.void],
+ [FakeArgument(attr.type, attr)]),
+ descriptor.getExtendedAttributes(attr,
+ setter=True))
+
+ def define(self, cgClass):
+ return ''
+
+
+class CGBindingImplClass(CGClass):
+ """
+ Common codegen for generating a C++ implementation of a WebIDL interface
+ """
+ def __init__(self, descriptor, cgMethod, cgGetter, cgSetter, wantGetParent=True, wrapMethodName="WrapObject", skipStaticMethods=False):
+ """
+ cgMethod, cgGetter and cgSetter are classes used to codegen methods,
+ getters and setters.
+ """
+ self.descriptor = descriptor
+ self._deps = descriptor.interface.getDeps()
+
+ iface = descriptor.interface
+
+ self.methodDecls = []
+
+ def appendMethod(m, isConstructor=False):
+ sigs = m.signatures()
+ for s in sigs[:-1]:
+ # Don't put a blank line after overloads, until we
+ # get to the last one.
+ self.methodDecls.append(cgMethod(descriptor, m, s,
+ isConstructor,
+ breakAfter=False))
+ self.methodDecls.append(cgMethod(descriptor, m, sigs[-1],
+ isConstructor))
+
+ if iface.ctor():
+ appendMethod(iface.ctor(), isConstructor=True)
+ for n in iface.namedConstructors:
+ appendMethod(n, isConstructor=True)
+ for m in iface.members:
+ if m.isMethod():
+ if m.isIdentifierLess():
+ continue
+ if not m.isStatic() or not skipStaticMethods:
+ appendMethod(m)
+ elif m.isAttr():
+ self.methodDecls.append(cgGetter(descriptor, m))
+ if not m.readonly:
+ self.methodDecls.append(cgSetter(descriptor, m))
+
+ # Now do the special operations
+ def appendSpecialOperation(name, op):
+ if op is None:
+ return
+ if name == "IndexedCreator" or name == "NamedCreator":
+ # These are identical to the setters
+ return
+ assert len(op.signatures()) == 1
+ returnType, args = op.signatures()[0]
+ # Make a copy of the args, since we plan to modify them.
+ args = list(args)
+ if op.isGetter() or op.isDeleter():
+ # This is a total hack. The '&' belongs with the
+ # type, not the name! But it works, and is simpler
+ # than trying to somehow make this pretty.
+ args.append(FakeArgument(BuiltinTypes[IDLBuiltinType.Types.boolean],
+ op, name="&found"))
+ if name == "Stringifier":
+ if op.isIdentifierLess():
+ # XXXbz I wish we were consistent about our renaming here.
+ name = "Stringify"
+ else:
+ # We already added this method
+ return
+ if name == "LegacyCaller":
+ if op.isIdentifierLess():
+ # XXXbz I wish we were consistent about our renaming here.
+ name = "LegacyCall"
+ else:
+ # We already added this method
+ return
+ if name == "Jsonifier":
+ # We already added this method
+ return
+ self.methodDecls.append(
+ CGNativeMember(descriptor, op,
+ name,
+ (returnType, args),
+ descriptor.getExtendedAttributes(op)))
+ # Sort things by name so we get stable ordering in the output.
+ ops = descriptor.operations.items()
+ ops.sort(key=lambda x: x[0])
+ for name, op in ops:
+ appendSpecialOperation(name, op)
+ # If we support indexed properties, then we need a Length()
+ # method so we know which indices are supported.
+ if descriptor.supportsIndexedProperties():
+ # But we don't need it if we already have an infallible
+ # "length" attribute, which we often do.
+ haveLengthAttr = any(
+ m for m in iface.members if m.isAttr() and
+ CGSpecializedGetter.makeNativeName(descriptor, m) == "Length")
+ if not haveLengthAttr:
+ self.methodDecls.append(
+ CGNativeMember(descriptor, FakeMember(),
+ "Length",
+ (BuiltinTypes[IDLBuiltinType.Types.unsigned_long],
+ []),
+ {"infallible": True}))
+ # And if we support named properties we need to be able to
+ # enumerate the supported names.
+ if descriptor.supportsNamedProperties():
+ self.methodDecls.append(
+ CGNativeMember(
+ descriptor, FakeMember(),
+ "GetSupportedNames",
+ (IDLSequenceType(None,
+ BuiltinTypes[IDLBuiltinType.Types.domstring]),
+ []),
+ {"infallible": True}))
+
+ wrapArgs = [Argument('JSContext*', 'aCx'),
+ Argument('JS::Handle<JSObject*>', 'aGivenProto')]
+ if not descriptor.wrapperCache:
+ wrapReturnType = "bool"
+ wrapArgs.append(Argument('JS::MutableHandle<JSObject*>',
+ 'aReflector'))
+ else:
+ wrapReturnType = "JSObject*"
+ self.methodDecls.insert(0,
+ ClassMethod(wrapMethodName, wrapReturnType,
+ wrapArgs, virtual=descriptor.wrapperCache,
+ breakAfterReturnDecl=" ",
+ override=descriptor.wrapperCache,
+ body=self.getWrapObjectBody()))
+ if wantGetParent:
+ self.methodDecls.insert(0,
+ ClassMethod("GetParentObject",
+ self.getGetParentObjectReturnType(),
+ [], const=True,
+ breakAfterReturnDecl=" ",
+ body=self.getGetParentObjectBody()))
+
+ # Invoke CGClass.__init__ in any subclasses afterwards to do the actual codegen.
+
+ def getWrapObjectBody(self):
+ return None
+
+ def getGetParentObjectReturnType(self):
+ return ("// TODO: return something sensible here, and change the return type\n"
+ "%s*" % self.descriptor.nativeType.split('::')[-1])
+
+ def getGetParentObjectBody(self):
+ return None
+
+ def deps(self):
+ return self._deps
+
+
+class CGExampleClass(CGBindingImplClass):
+ """
+ Codegen for the actual example class implementation for this descriptor
+ """
+ def __init__(self, descriptor):
+ CGBindingImplClass.__init__(self, descriptor,
+ CGExampleMethod, CGExampleGetter, CGExampleSetter,
+ wantGetParent=descriptor.wrapperCache)
+
+ self.parentIface = descriptor.interface.parent
+ if self.parentIface:
+ self.parentDesc = descriptor.getDescriptor(
+ self.parentIface.identifier.name)
+ bases = [ClassBase(self.nativeLeafName(self.parentDesc))]
+ else:
+ bases = [ClassBase("nsISupports /* or NonRefcountedDOMObject if this is a non-refcounted object */")]
+ if descriptor.wrapperCache:
+ bases.append(ClassBase("nsWrapperCache /* Change wrapperCache in the binding configuration if you don't want this */"))
+
+ destructorVisibility = "protected"
+ if self.parentIface:
+ extradeclarations = (
+ "public:\n"
+ " NS_DECL_ISUPPORTS_INHERITED\n"
+ " NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(%s, %s)\n"
+ "\n" % (self.nativeLeafName(descriptor),
+ self.nativeLeafName(self.parentDesc)))
+ else:
+ extradeclarations = (
+ "public:\n"
+ " NS_DECL_CYCLE_COLLECTING_ISUPPORTS\n"
+ " NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(%s)\n"
+ "\n" % self.nativeLeafName(descriptor))
+
+ if descriptor.interface.hasChildInterfaces():
+ decorators = ""
+ else:
+ decorators = "final"
+
+ CGClass.__init__(self, self.nativeLeafName(descriptor),
+ bases=bases,
+ constructors=[ClassConstructor([],
+ visibility="public")],
+ destructor=ClassDestructor(visibility=destructorVisibility),
+ methods=self.methodDecls,
+ decorators=decorators,
+ extradeclarations=extradeclarations)
+
+ def define(self):
+ # Just override CGClass and do our own thing
+ ctordtor = dedent("""
+ ${nativeType}::${nativeType}()
+ {
+ // Add |MOZ_COUNT_CTOR(${nativeType});| for a non-refcounted object.
+ }
+
+ ${nativeType}::~${nativeType}()
+ {
+ // Add |MOZ_COUNT_DTOR(${nativeType});| for a non-refcounted object.
+ }
+ """)
+
+ if self.parentIface:
+ ccImpl = dedent("""
+
+ // Only needed for refcounted objects.
+ # error "If you don't have members that need cycle collection,
+ # then remove all the cycle collection bits from this
+ # implementation and the corresponding header. If you do, you
+ # want NS_IMPL_CYCLE_COLLECTION_INHERITED(${nativeType},
+ # ${parentType}, your, members, here)"
+ NS_IMPL_ADDREF_INHERITED(${nativeType}, ${parentType})
+ NS_IMPL_RELEASE_INHERITED(${nativeType}, ${parentType})
+ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(${nativeType})
+ NS_INTERFACE_MAP_END_INHERITING(${parentType})
+
+ """)
+ else:
+ ccImpl = dedent("""
+
+ // Only needed for refcounted objects.
+ NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(${nativeType})
+ NS_IMPL_CYCLE_COLLECTING_ADDREF(${nativeType})
+ NS_IMPL_CYCLE_COLLECTING_RELEASE(${nativeType})
+ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(${nativeType})
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+ NS_INTERFACE_MAP_END
+
+ """)
+
+ if self.descriptor.wrapperCache:
+ reflectorArg = ""
+ reflectorPassArg = ""
+ returnType = "JSObject*"
+ else:
+ reflectorArg = ", JS::MutableHandle<JSObject*> aReflector"
+ reflectorPassArg = ", aReflector"
+ returnType = "bool"
+ classImpl = ccImpl + ctordtor + "\n" + dedent("""
+ ${returnType}
+ ${nativeType}::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto${reflectorArg})
+ {
+ return ${ifaceName}Binding::Wrap(aCx, this, aGivenProto${reflectorPassArg});
+ }
+
+ """)
+ return string.Template(classImpl).substitute(
+ ifaceName=self.descriptor.name,
+ nativeType=self.nativeLeafName(self.descriptor),
+ parentType=self.nativeLeafName(self.parentDesc) if self.parentIface else "",
+ returnType=returnType,
+ reflectorArg=reflectorArg,
+ reflectorPassArg=reflectorPassArg)
+
+ @staticmethod
+ def nativeLeafName(descriptor):
+ return descriptor.nativeType.split('::')[-1]
+
+
+class CGExampleRoot(CGThing):
+ """
+ Root codegen class for example implementation generation. Instantiate the
+ class and call declare or define to generate header or cpp code,
+ respectively.
+ """
+ def __init__(self, config, interfaceName):
+ descriptor = config.getDescriptor(interfaceName)
+
+ self.root = CGWrapper(CGExampleClass(descriptor),
+ pre="\n", post="\n")
+
+ self.root = CGNamespace.build(["mozilla", "dom"], self.root)
+
+ builder = ForwardDeclarationBuilder()
+ for member in descriptor.interface.members:
+ if not member.isAttr() and not member.isMethod():
+ continue
+ if member.isStatic():
+ builder.addInMozillaDom("GlobalObject")
+ if member.isAttr() and not member.isMaplikeOrSetlikeAttr():
+ builder.forwardDeclareForType(member.type, config)
+ else:
+ assert member.isMethod()
+ if not member.isMaplikeOrSetlikeOrIterableMethod():
+ for sig in member.signatures():
+ builder.forwardDeclareForType(sig[0], config)
+ for arg in sig[1]:
+ builder.forwardDeclareForType(arg.type, config)
+
+ self.root = CGList([builder.build(),
+ self.root], "\n")
+
+ # Throw in our #includes
+ self.root = CGHeaders([], [], [], [],
+ ["nsWrapperCache.h",
+ "nsCycleCollectionParticipant.h",
+ "mozilla/Attributes.h",
+ "mozilla/ErrorResult.h",
+ "mozilla/dom/BindingDeclarations.h",
+ "js/TypeDecls.h"],
+ ["mozilla/dom/%s.h" % interfaceName,
+ ("mozilla/dom/%s" %
+ CGHeaders.getDeclarationFilename(descriptor.interface))], "", self.root)
+
+ # And now some include guards
+ self.root = CGIncludeGuard(interfaceName, self.root)
+
+ # And our license block comes before everything else
+ self.root = CGWrapper(self.root, pre=dedent("""
+ /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+ /* vim:set ts=2 sw=2 sts=2 et cindent: */
+ /* 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/. */
+
+ """))
+
+ def declare(self):
+ return self.root.declare()
+
+ def define(self):
+ return self.root.define()
+
+
+def jsImplName(name):
+ return name + "JSImpl"
+
+
+class CGJSImplMember(CGNativeMember):
+ """
+ Base class for generating code for the members of the implementation class
+ for a JS-implemented WebIDL interface.
+ """
+ def __init__(self, descriptorProvider, member, name, signature,
+ extendedAttrs, breakAfter=True, passJSBitsAsNeeded=True,
+ visibility="public", variadicIsSequence=False,
+ virtual=False, override=False):
+ CGNativeMember.__init__(self, descriptorProvider, member, name,
+ signature, extendedAttrs, breakAfter=breakAfter,
+ passJSBitsAsNeeded=passJSBitsAsNeeded,
+ visibility=visibility,
+ variadicIsSequence=variadicIsSequence,
+ virtual=virtual,
+ override=override)
+ self.body = self.getImpl()
+
+ def getArgs(self, returnType, argList):
+ args = CGNativeMember.getArgs(self, returnType, argList)
+ args.append(Argument("JSCompartment*", "aCompartment", "nullptr"))
+ return args
+
+
+class CGJSImplMethod(CGJSImplMember):
+ """
+ Class for generating code for the methods for a JS-implemented WebIDL
+ interface.
+ """
+ def __init__(self, descriptor, method, signature, isConstructor, breakAfter=True):
+ virtual = False
+ override = False
+ if (method.identifier.name == "eventListenerWasAdded" or
+ method.identifier.name == "eventListenerWasRemoved"):
+ virtual = True
+ override = True
+
+ self.signature = signature
+ self.descriptor = descriptor
+ self.isConstructor = isConstructor
+ CGJSImplMember.__init__(self, descriptor, method,
+ CGSpecializedMethod.makeNativeName(descriptor,
+ method),
+ signature,
+ descriptor.getExtendedAttributes(method),
+ breakAfter=breakAfter,
+ variadicIsSequence=True,
+ passJSBitsAsNeeded=False,
+ virtual=virtual,
+ override=override)
+
+ def getArgs(self, returnType, argList):
+ if self.isConstructor:
+ # Skip the JSCompartment bits for constructors; it's handled
+ # manually in getImpl.
+ return CGNativeMember.getArgs(self, returnType, argList)
+ return CGJSImplMember.getArgs(self, returnType, argList)
+
+ def getImpl(self):
+ args = self.getArgs(self.signature[0], self.signature[1])
+ if not self.isConstructor:
+ return 'return mImpl->%s(%s);\n' % (self.name, ", ".join(arg.name for arg in args))
+
+ assert self.descriptor.interface.isJSImplemented()
+ if self.name != 'Constructor':
+ raise TypeError("Named constructors are not supported for JS implemented WebIDL. See bug 851287.")
+ if len(self.signature[1]) != 0:
+ # The first two arguments to the constructor implementation are not
+ # arguments to the WebIDL constructor, so don't pass them to __Init()
+ assert args[0].argType == 'const GlobalObject&'
+ assert args[1].argType == 'JSContext*'
+ constructorArgs = [arg.name for arg in args[2:]]
+ constructorArgs.append("js::GetObjectCompartment(scopeObj)")
+ initCall = fill(
+ """
+ // Wrap the object before calling __Init so that __DOM_IMPL__ is available.
+ JS::Rooted<JSObject*> scopeObj(cx, globalHolder->GetGlobalJSObject());
+ MOZ_ASSERT(js::IsObjectInContextCompartment(scopeObj, cx));
+ JS::Rooted<JS::Value> wrappedVal(cx);
+ if (!GetOrCreateDOMReflector(cx, impl, &wrappedVal)) {
+ //XXX Assertion disabled for now, see bug 991271.
+ MOZ_ASSERT(true || JS_IsExceptionPending(cx));
+ aRv.Throw(NS_ERROR_UNEXPECTED);
+ return nullptr;
+ }
+ // Initialize the object with the constructor arguments.
+ impl->mImpl->__Init(${args});
+ if (aRv.Failed()) {
+ return nullptr;
+ }
+ """,
+ args=", ".join(constructorArgs))
+ else:
+ initCall = ""
+ return genConstructorBody(self.descriptor, initCall)
+
+
+def genConstructorBody(descriptor, initCall=""):
+ return fill(
+ """
+ JS::Rooted<JSObject*> jsImplObj(cx);
+ nsCOMPtr<nsIGlobalObject> globalHolder =
+ ConstructJSImplementation("${contractId}", global, &jsImplObj, aRv);
+ if (aRv.Failed()) {
+ return nullptr;
+ }
+ // Build the C++ implementation.
+ RefPtr<${implClass}> impl = new ${implClass}(jsImplObj, globalHolder);
+ $*{initCall}
+ return impl.forget();
+ """,
+ contractId=descriptor.interface.getJSImplementation(),
+ implClass=descriptor.name,
+ initCall=initCall)
+
+
+# We're always fallible
+def callbackGetterName(attr, descriptor):
+ return "Get" + MakeNativeName(
+ descriptor.binaryNameFor(attr.identifier.name))
+
+
+def callbackSetterName(attr, descriptor):
+ return "Set" + MakeNativeName(
+ descriptor.binaryNameFor(attr.identifier.name))
+
+
+class CGJSImplClearCachedValueMethod(CGAbstractBindingMethod):
+ def __init__(self, descriptor, attr):
+ if attr.getExtendedAttribute("StoreInSlot"):
+ raise TypeError("[StoreInSlot] is not supported for JS-implemented WebIDL. See bug 1056325.")
+
+ CGAbstractBindingMethod.__init__(self, descriptor,
+ MakeJSImplClearCachedValueNativeName(attr),
+ JSNativeArguments())
+ self.attr = attr
+
+ def generate_code(self):
+ return CGGeneric(fill(
+ """
+ ${bindingNamespace}::${fnName}(self);
+ args.rval().setUndefined();
+ return true;
+ """,
+ bindingNamespace=toBindingNamespace(self.descriptor.name),
+ fnName=MakeClearCachedValueNativeName(self.attr)))
+
+
+class CGJSImplGetter(CGJSImplMember):
+ """
+ Class for generating code for the getters of attributes for a JS-implemented
+ WebIDL interface.
+ """
+ def __init__(self, descriptor, attr):
+ CGJSImplMember.__init__(self, descriptor, attr,
+ CGSpecializedGetter.makeNativeName(descriptor,
+ attr),
+ (attr.type, []),
+ descriptor.getExtendedAttributes(attr,
+ getter=True),
+ passJSBitsAsNeeded=False)
+
+ def getImpl(self):
+ callbackArgs = [arg.name for arg in self.getArgs(self.member.type, [])]
+ return 'return mImpl->%s(%s);\n' % (
+ callbackGetterName(self.member, self.descriptorProvider),
+ ", ".join(callbackArgs))
+
+
+class CGJSImplSetter(CGJSImplMember):
+ """
+ Class for generating code for the setters of attributes for a JS-implemented
+ WebIDL interface.
+ """
+ def __init__(self, descriptor, attr):
+ CGJSImplMember.__init__(self, descriptor, attr,
+ CGSpecializedSetter.makeNativeName(descriptor,
+ attr),
+ (BuiltinTypes[IDLBuiltinType.Types.void],
+ [FakeArgument(attr.type, attr)]),
+ descriptor.getExtendedAttributes(attr,
+ setter=True),
+ passJSBitsAsNeeded=False)
+
+ def getImpl(self):
+ callbackArgs = [arg.name for arg in self.getArgs(BuiltinTypes[IDLBuiltinType.Types.void],
+ [FakeArgument(self.member.type, self.member)])]
+ return 'mImpl->%s(%s);\n' % (
+ callbackSetterName(self.member, self.descriptorProvider),
+ ", ".join(callbackArgs))
+
+
+class CGJSImplClass(CGBindingImplClass):
+ def __init__(self, descriptor):
+ CGBindingImplClass.__init__(self, descriptor, CGJSImplMethod, CGJSImplGetter, CGJSImplSetter, skipStaticMethods=True)
+
+ if descriptor.interface.parent:
+ parentClass = descriptor.getDescriptor(
+ descriptor.interface.parent.identifier.name).jsImplParent
+ baseClasses = [ClassBase(parentClass)]
+ isupportsDecl = "NS_DECL_ISUPPORTS_INHERITED\n"
+ ccDecl = ("NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(%s, %s)\n" %
+ (descriptor.name, parentClass))
+ constructorBody = dedent("""
+ // Make sure we're an nsWrapperCache already
+ MOZ_ASSERT(static_cast<nsWrapperCache*>(this));
+ // And that our ancestor has not called SetIsNotDOMBinding()
+ MOZ_ASSERT(IsDOMBinding());
+ """)
+ extradefinitions = fill(
+ """
+ NS_IMPL_CYCLE_COLLECTION_INHERITED(${ifaceName}, ${parentClass}, mImpl, mParent)
+ NS_IMPL_ADDREF_INHERITED(${ifaceName}, ${parentClass})
+ NS_IMPL_RELEASE_INHERITED(${ifaceName}, ${parentClass})
+ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(${ifaceName})
+ NS_INTERFACE_MAP_END_INHERITING(${parentClass})
+ """,
+ ifaceName=self.descriptor.name,
+ parentClass=parentClass)
+ else:
+ baseClasses = [ClassBase("nsSupportsWeakReference"),
+ ClassBase("nsWrapperCache")]
+ isupportsDecl = "NS_DECL_CYCLE_COLLECTING_ISUPPORTS\n"
+ ccDecl = ("NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(%s)\n" %
+ descriptor.name)
+ extradefinitions = fill(
+ """
+ NS_IMPL_CYCLE_COLLECTION_CLASS(${ifaceName})
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(${ifaceName})
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mImpl)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mParent)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+ tmp->ClearWeakReferences();
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(${ifaceName})
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mImpl)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mParent)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+ NS_IMPL_CYCLE_COLLECTION_TRACE_WRAPPERCACHE(${ifaceName})
+ NS_IMPL_CYCLE_COLLECTING_ADDREF(${ifaceName})
+ NS_IMPL_CYCLE_COLLECTING_RELEASE(${ifaceName})
+ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(${ifaceName})
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+ NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+ NS_INTERFACE_MAP_END
+ """,
+ ifaceName=self.descriptor.name)
+
+ extradeclarations = fill(
+ """
+ public:
+ $*{isupportsDecl}
+ $*{ccDecl}
+
+ private:
+ RefPtr<${jsImplName}> mImpl;
+ nsCOMPtr<nsISupports> mParent;
+
+ """,
+ isupportsDecl=isupportsDecl,
+ ccDecl=ccDecl,
+ jsImplName=jsImplName(descriptor.name))
+
+ if descriptor.interface.hasChildInterfaces():
+ decorators = ""
+ # We need a protected virtual destructor our subclasses can use
+ destructor = ClassDestructor(virtual=True, visibility="protected")
+ else:
+ decorators = "final"
+ destructor = ClassDestructor(virtual=False, visibility="private")
+
+ baseConstructors = [
+ ("mImpl(new %s(nullptr, aJSImplObject, /* aIncumbentGlobal = */ nullptr))" %
+ jsImplName(descriptor.name)),
+ "mParent(aParent)"]
+ parentInterface = descriptor.interface.parent
+ while parentInterface:
+ if parentInterface.isJSImplemented():
+ baseConstructors.insert(
+ 0, "%s(aJSImplObject, aParent)" % parentClass)
+ break
+ parentInterface = parentInterface.parent
+ if not parentInterface and descriptor.interface.parent:
+ # We only have C++ ancestors, so only pass along the window
+ baseConstructors.insert(0,
+ "%s(aParent)" % parentClass)
+
+ constructor = ClassConstructor(
+ [Argument("JS::Handle<JSObject*>", "aJSImplObject"),
+ Argument("nsIGlobalObject*", "aParent")],
+ visibility="public",
+ baseConstructors=baseConstructors)
+
+ self.methodDecls.append(
+ ClassMethod("_Create",
+ "bool",
+ JSNativeArguments(),
+ static=True,
+ body=self.getCreateFromExistingBody()))
+
+ CGClass.__init__(self, descriptor.name,
+ bases=baseClasses,
+ constructors=[constructor],
+ destructor=destructor,
+ methods=self.methodDecls,
+ decorators=decorators,
+ extradeclarations=extradeclarations,
+ extradefinitions=extradefinitions)
+
+ def getWrapObjectBody(self):
+ return fill(
+ """
+ JS::Rooted<JSObject*> obj(aCx, ${name}Binding::Wrap(aCx, this, aGivenProto));
+ if (!obj) {
+ return nullptr;
+ }
+
+ // Now define it on our chrome object
+ JSAutoCompartment ac(aCx, mImpl->Callback());
+ if (!JS_WrapObject(aCx, &obj)) {
+ return nullptr;
+ }
+ if (!JS_DefineProperty(aCx, mImpl->Callback(), "__DOM_IMPL__", obj, 0)) {
+ return nullptr;
+ }
+ return obj;
+ """,
+ name=self.descriptor.name)
+
+ def getGetParentObjectReturnType(self):
+ return "nsISupports*"
+
+ def getGetParentObjectBody(self):
+ return "return mParent;\n"
+
+ def getCreateFromExistingBody(self):
+ # XXXbz we could try to get parts of this (e.g. the argument
+ # conversions) auto-generated by somehow creating an IDLMethod and
+ # adding it to our interface, but we'd still need to special-case the
+ # implementation slightly to have it not try to forward to the JS
+ # object...
+ return fill(
+ """
+ JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
+ if (args.length() < 2) {
+ return ThrowErrorMessage(cx, MSG_MISSING_ARGUMENTS, "${ifaceName}._create");
+ }
+ if (!args[0].isObject()) {
+ return ThrowErrorMessage(cx, MSG_NOT_OBJECT, "Argument 1 of ${ifaceName}._create");
+ }
+ if (!args[1].isObject()) {
+ return ThrowErrorMessage(cx, MSG_NOT_OBJECT, "Argument 2 of ${ifaceName}._create");
+ }
+
+ // GlobalObject will go through wrappers as needed for us, and
+ // is simpler than the right UnwrapArg incantation.
+ GlobalObject global(cx, &args[0].toObject());
+ if (global.Failed()) {
+ return false;
+ }
+ nsCOMPtr<nsIGlobalObject> globalHolder = do_QueryInterface(global.GetAsSupports());
+ MOZ_ASSERT(globalHolder);
+ JS::Rooted<JSObject*> arg(cx, &args[1].toObject());
+ RefPtr<${implName}> impl = new ${implName}(arg, globalHolder);
+ MOZ_ASSERT(js::IsObjectInContextCompartment(arg, cx));
+ return GetOrCreateDOMReflector(cx, impl, args.rval());
+ """,
+ ifaceName=self.descriptor.interface.identifier.name,
+ implName=self.descriptor.name)
+
+
+def isJSImplementedDescriptor(descriptorProvider):
+ return (isinstance(descriptorProvider, Descriptor) and
+ descriptorProvider.interface.isJSImplemented())
+
+
+class CGCallback(CGClass):
+ def __init__(self, idlObject, descriptorProvider, baseName, methods,
+ getters=[], setters=[]):
+ self.baseName = baseName
+ self._deps = idlObject.getDeps()
+ self.idlObject = idlObject
+ self.name = idlObject.identifier.name
+ if isJSImplementedDescriptor(descriptorProvider):
+ self.name = jsImplName(self.name)
+ # For our public methods that needThisHandling we want most of the
+ # same args and the same return type as what CallbackMember
+ # generates. So we want to take advantage of all its
+ # CGNativeMember infrastructure, but that infrastructure can't deal
+ # with templates and most especially template arguments. So just
+ # cheat and have CallbackMember compute all those things for us.
+ realMethods = []
+ for method in methods:
+ if not isinstance(method, CallbackMember) or not method.needThisHandling:
+ realMethods.append(method)
+ else:
+ realMethods.extend(self.getMethodImpls(method))
+ realMethods.append(
+ ClassMethod("operator==", "bool",
+ [Argument("const %s&" % self.name, "aOther")],
+ inline=True, bodyInHeader=True,
+ const=True,
+ body=("return %s::operator==(aOther);\n" % baseName)))
+ CGClass.__init__(self, self.name,
+ bases=[ClassBase(baseName)],
+ constructors=self.getConstructors(),
+ methods=realMethods+getters+setters)
+
+ def getConstructors(self):
+ if (not self.idlObject.isInterface() and
+ not self.idlObject._treatNonObjectAsNull):
+ body = "MOZ_ASSERT(JS::IsCallable(mCallback));\n"
+ else:
+ # Not much we can assert about it, other than not being null, and
+ # CallbackObject does that already.
+ body = ""
+ return [
+ ClassConstructor(
+ [Argument("JSContext*", "aCx"),
+ Argument("JS::Handle<JSObject*>", "aCallback"),
+ Argument("nsIGlobalObject*", "aIncumbentGlobal")],
+ bodyInHeader=True,
+ visibility="public",
+ explicit=True,
+ baseConstructors=[
+ "%s(aCx, aCallback, aIncumbentGlobal)" % self.baseName,
+ ],
+ body=body),
+ ClassConstructor(
+ [Argument("JSContext*", "aCx"),
+ Argument("JS::Handle<JSObject*>", "aCallback"),
+ Argument("nsIGlobalObject*", "aIncumbentGlobal"),
+ Argument("const FastCallbackConstructor&", "")],
+ bodyInHeader=True,
+ visibility="public",
+ explicit=True,
+ baseConstructors=[
+ "%s(aCx, aCallback, aIncumbentGlobal, FastCallbackConstructor())" % self.baseName,
+ ],
+ body=body),
+ ClassConstructor(
+ [Argument("JS::Handle<JSObject*>", "aCallback"),
+ Argument("JS::Handle<JSObject*>", "aAsyncStack"),
+ Argument("nsIGlobalObject*", "aIncumbentGlobal")],
+ bodyInHeader=True,
+ visibility="public",
+ explicit=True,
+ baseConstructors=[
+ "%s(aCallback, aAsyncStack, aIncumbentGlobal)" % self.baseName,
+ ],
+ body=body)]
+
+ def getMethodImpls(self, method):
+ assert method.needThisHandling
+ args = list(method.args)
+ # Strip out the JSContext*/JSObject* args
+ # that got added.
+ assert args[0].name == "cx" and args[0].argType == "JSContext*"
+ assert args[1].name == "aThisVal" and args[1].argType == "JS::Handle<JS::Value>"
+ args = args[2:]
+
+ # Now remember which index the ErrorResult argument is at;
+ # we'll need this below.
+ assert args[-1].name == "aRv" and args[-1].argType == "ErrorResult&"
+ rvIndex = len(args) - 1
+ assert rvIndex >= 0
+
+ # Record the names of all the arguments, so we can use them when we call
+ # the private method.
+ argnames = [arg.name for arg in args]
+ argnamesWithThis = ["s.GetContext()", "thisValJS"] + argnames
+ argnamesWithoutThis = ["s.GetContext()", "JS::UndefinedHandleValue"] + argnames
+ # Now that we've recorded the argnames for our call to our private
+ # method, insert our optional argument for the execution reason.
+ args.append(Argument("const char*", "aExecutionReason",
+ "nullptr"))
+
+ # Make copies of the arg list for the two "without rv" overloads. Note
+ # that those don't need aExceptionHandling or aCompartment arguments
+ # because those would make not sense anyway: the only sane thing to do
+ # with exceptions in the "without rv" cases is to report them.
+ argsWithoutRv = list(args)
+ argsWithoutRv.pop(rvIndex)
+ argsWithoutThisAndRv = list(argsWithoutRv)
+
+ # Add the potional argument for deciding whether the CallSetup should
+ # re-throw exceptions on aRv.
+ args.append(Argument("ExceptionHandling", "aExceptionHandling",
+ "eReportExceptions"))
+ # And the argument for communicating when exceptions should really be
+ # rethrown. In particular, even when aExceptionHandling is
+ # eRethrowExceptions they won't get rethrown if aCompartment is provided
+ # and its principal doesn't subsume either the callback or the
+ # exception.
+ args.append(Argument("JSCompartment*", "aCompartment", "nullptr"))
+ # And now insert our template argument.
+ argsWithoutThis = list(args)
+ args.insert(0, Argument("const T&", "thisVal"))
+ argsWithoutRv.insert(0, Argument("const T&", "thisVal"))
+
+ argnamesWithoutThisAndRv = [arg.name for arg in argsWithoutThisAndRv]
+ argnamesWithoutThisAndRv.insert(rvIndex, "rv");
+ # If we just leave things like that, and have no actual arguments in the
+ # IDL, we will end up trying to call the templated "without rv" overload
+ # with "rv" as the thisVal. That's no good. So explicitly append the
+ # aExceptionHandling and aCompartment values we need to end up matching
+ # the signature of our non-templated "with rv" overload.
+ argnamesWithoutThisAndRv.extend(["eReportExceptions", "nullptr"])
+
+ argnamesWithoutRv = [arg.name for arg in argsWithoutRv]
+ # Note that we need to insert at rvIndex + 1, since we inserted a
+ # thisVal arg at the start.
+ argnamesWithoutRv.insert(rvIndex + 1, "rv")
+
+ errorReturn = method.getDefaultRetval()
+
+ setupCall = fill(
+ """
+ if (!aExecutionReason) {
+ aExecutionReason = "${executionReason}";
+ }
+ CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
+ if (!s.GetContext()) {
+ MOZ_ASSERT(aRv.Failed());
+ return${errorReturn};
+ }
+ """,
+ errorReturn=errorReturn,
+ executionReason=method.getPrettyName())
+
+ bodyWithThis = fill(
+ """
+ $*{setupCall}
+ JS::Rooted<JS::Value> thisValJS(s.GetContext());
+ if (!ToJSValue(s.GetContext(), thisVal, &thisValJS)) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return${errorReturn};
+ }
+ return ${methodName}(${callArgs});
+ """,
+ setupCall=setupCall,
+ errorReturn=errorReturn,
+ methodName=method.name,
+ callArgs=", ".join(argnamesWithThis))
+ bodyWithoutThis = fill(
+ """
+ $*{setupCall}
+ return ${methodName}(${callArgs});
+ """,
+ setupCall=setupCall,
+ errorReturn=errorReturn,
+ methodName=method.name,
+ callArgs=", ".join(argnamesWithoutThis))
+ bodyWithThisWithoutRv = fill(
+ """
+ IgnoredErrorResult rv;
+ return ${methodName}(${callArgs});
+ """,
+ methodName=method.name,
+ callArgs=", ".join(argnamesWithoutRv))
+ bodyWithoutThisAndRv = fill(
+ """
+ IgnoredErrorResult rv;
+ return ${methodName}(${callArgs});
+ """,
+ methodName=method.name,
+ callArgs=", ".join(argnamesWithoutThisAndRv))
+
+ return [ClassMethod(method.name, method.returnType, args,
+ bodyInHeader=True,
+ templateArgs=["typename T"],
+ body=bodyWithThis),
+ ClassMethod(method.name, method.returnType, argsWithoutThis,
+ bodyInHeader=True,
+ body=bodyWithoutThis),
+ ClassMethod(method.name, method.returnType, argsWithoutRv,
+ bodyInHeader=True,
+ templateArgs=["typename T"],
+ body=bodyWithThisWithoutRv),
+ ClassMethod(method.name, method.returnType, argsWithoutThisAndRv,
+ bodyInHeader=True,
+ body=bodyWithoutThisAndRv),
+ method]
+
+ def deps(self):
+ return self._deps
+
+
+class CGCallbackFunction(CGCallback):
+ def __init__(self, callback, descriptorProvider):
+ self.callback = callback
+ CGCallback.__init__(self, callback, descriptorProvider,
+ "CallbackFunction",
+ methods=[CallCallback(callback, descriptorProvider)])
+
+ def getConstructors(self):
+ return CGCallback.getConstructors(self) + [
+ ClassConstructor(
+ [Argument("CallbackFunction*", "aOther")],
+ bodyInHeader=True,
+ visibility="public",
+ explicit=True,
+ baseConstructors=["CallbackFunction(aOther)"])]
+
+
+class CGFastCallback(CGClass):
+ def __init__(self, idlObject):
+ self._deps = idlObject.getDeps()
+ baseName = idlObject.identifier.name
+ constructor = ClassConstructor(
+ [Argument("JSContext*", "aCx"),
+ Argument("JS::Handle<JSObject*>", "aCallback"),
+ Argument("nsIGlobalObject*", "aIncumbentGlobal")],
+ bodyInHeader=True,
+ visibility="public",
+ explicit=True,
+ baseConstructors=[
+ "%s(aCx, aCallback, aIncumbentGlobal, FastCallbackConstructor())" %
+ baseName,
+ ],
+ body="")
+
+ traceMethod = ClassMethod("Trace", "void",
+ [Argument("JSTracer*", "aTracer")],
+ inline=True,
+ bodyInHeader=True,
+ visibility="public",
+ body="%s::Trace(aTracer);\n" % baseName)
+ holdMethod = ClassMethod("HoldJSObjectsIfMoreThanOneOwner", "void",
+ [],
+ inline=True,
+ bodyInHeader=True,
+ visibility="public",
+ body=(
+ "%s::HoldJSObjectsIfMoreThanOneOwner();\n" %
+ baseName))
+
+ CGClass.__init__(self, "Fast%s" % baseName,
+ bases=[ClassBase(baseName)],
+ constructors=[constructor],
+ methods=[traceMethod, holdMethod])
+
+ def deps(self):
+ return self._deps
+
+
+class CGCallbackInterface(CGCallback):
+ def __init__(self, descriptor, typedArraysAreStructs=False):
+ iface = descriptor.interface
+ attrs = [m for m in iface.members if m.isAttr() and not m.isStatic()]
+ getters = [CallbackGetter(a, descriptor, typedArraysAreStructs)
+ for a in attrs]
+ setters = [CallbackSetter(a, descriptor, typedArraysAreStructs)
+ for a in attrs if not a.readonly]
+ methods = [m for m in iface.members
+ if m.isMethod() and not m.isStatic() and not m.isIdentifierLess()]
+ methods = [CallbackOperation(m, sig, descriptor, typedArraysAreStructs)
+ for m in methods for sig in m.signatures()]
+ if iface.isJSImplemented() and iface.ctor():
+ sigs = descriptor.interface.ctor().signatures()
+ if len(sigs) != 1:
+ raise TypeError("We only handle one constructor. See bug 869268.")
+ methods.append(CGJSImplInitOperation(sigs[0], descriptor))
+ if any(m.isAttr() or m.isMethod() for m in iface.members) or (iface.isJSImplemented() and iface.ctor()):
+ methods.append(initIdsClassMethod([descriptor.binaryNameFor(m.identifier.name)
+ for m in iface.members
+ if m.isAttr() or m.isMethod()] +
+ (["__init"] if iface.isJSImplemented() and iface.ctor() else []),
+ iface.identifier.name + "Atoms"))
+ CGCallback.__init__(self, iface, descriptor, "CallbackInterface",
+ methods, getters=getters, setters=setters)
+
+
+class FakeMember():
+ def __init__(self, name=None):
+ self.treatNullAs = "Default"
+ if name is not None:
+ self.identifier = FakeIdentifier(name)
+
+ def isStatic(self):
+ return False
+
+ def isAttr(self):
+ return False
+
+ def isMethod(self):
+ return False
+
+ def getExtendedAttribute(self, name):
+ # Claim to be a [NewObject] so we can avoid the "return a raw pointer"
+ # comments CGNativeMember codegen would otherwise stick in.
+ if name == "NewObject":
+ return True
+ return None
+
+
+class CallbackMember(CGNativeMember):
+ # XXXbz It's OK to use CallbackKnownNotGray for wrapScope because
+ # CallSetup already handled the unmark-gray bits for us. we don't have
+ # anything better to use for 'obj', really...
+ def __init__(self, sig, name, descriptorProvider, needThisHandling,
+ rethrowContentException=False, typedArraysAreStructs=False,
+ wrapScope='CallbackKnownNotGray()'):
+ """
+ needThisHandling is True if we need to be able to accept a specified
+ thisObj, False otherwise.
+ """
+ assert not rethrowContentException or not needThisHandling
+
+ self.retvalType = sig[0]
+ self.originalSig = sig
+ args = sig[1]
+ self.argCount = len(args)
+ if self.argCount > 0:
+ # Check for variadic arguments
+ lastArg = args[self.argCount-1]
+ if lastArg.variadic:
+ self.argCountStr = ("(%d - 1) + %s.Length()" %
+ (self.argCount, lastArg.identifier.name))
+ else:
+ self.argCountStr = "%d" % self.argCount
+ self.needThisHandling = needThisHandling
+ # If needThisHandling, we generate ourselves as private and the caller
+ # will handle generating public versions that handle the "this" stuff.
+ visibility = "private" if needThisHandling else "public"
+ self.rethrowContentException = rethrowContentException
+
+ self.wrapScope = wrapScope
+ # We don't care, for callback codegen, whether our original member was
+ # a method or attribute or whatnot. Just always pass FakeMember()
+ # here.
+ CGNativeMember.__init__(self, descriptorProvider, FakeMember(),
+ name, (self.retvalType, args),
+ extendedAttrs={},
+ passJSBitsAsNeeded=False,
+ visibility=visibility,
+ typedArraysAreStructs=typedArraysAreStructs)
+ # We have to do all the generation of our body now, because
+ # the caller relies on us throwing if we can't manage it.
+ self.exceptionCode = ("aRv.Throw(NS_ERROR_UNEXPECTED);\n"
+ "return%s;\n" % self.getDefaultRetval())
+ self.body = self.getImpl()
+
+ def getImpl(self):
+ setupCall = self.getCallSetup()
+ declRval = self.getRvalDecl()
+ if self.argCount > 0:
+ argvDecl = fill(
+ """
+ JS::AutoValueVector argv(cx);
+ if (!argv.resize(${argCount})) {
+ aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+ return${errorReturn};
+ }
+ """,
+ argCount=self.argCountStr,
+ errorReturn=self.getDefaultRetval())
+ else:
+ # Avoid weird 0-sized arrays
+ argvDecl = ""
+ convertArgs = self.getArgConversions()
+ doCall = self.getCall()
+ returnResult = self.getResultConversion()
+
+ return setupCall + declRval + argvDecl + convertArgs + doCall + returnResult
+
+ def getResultConversion(self):
+ replacements = {
+ "val": "rval",
+ "holderName": "rvalHolder",
+ "declName": "rvalDecl",
+ # We actually want to pass in a null scope object here, because
+ # wrapping things into our current compartment (that of mCallback)
+ # is what we want.
+ "obj": "nullptr",
+ "passedToJSImpl": "false"
+ }
+
+ if isJSImplementedDescriptor(self.descriptorProvider):
+ isCallbackReturnValue = "JSImpl"
+ else:
+ isCallbackReturnValue = "Callback"
+ sourceDescription = "return value of %s" % self.getPrettyName()
+ convertType = instantiateJSToNativeConversion(
+ getJSToNativeConversionInfo(self.retvalType,
+ self.descriptorProvider,
+ exceptionCode=self.exceptionCode,
+ isCallbackReturnValue=isCallbackReturnValue,
+ # Allow returning a callback type that
+ # allows non-callable objects.
+ allowTreatNonCallableAsNull=True,
+ sourceDescription=sourceDescription),
+ replacements)
+ assignRetval = string.Template(
+ self.getRetvalInfo(self.retvalType,
+ False)[2]).substitute(replacements)
+ type = convertType.define()
+ return type + assignRetval
+
+ def getArgConversions(self):
+ # Just reget the arglist from self.originalSig, because our superclasses
+ # just have way to many members they like to clobber, so I can't find a
+ # safe member name to store it in.
+ argConversions = [self.getArgConversion(i, arg)
+ for i, arg in enumerate(self.originalSig[1])]
+ if not argConversions:
+ return "\n"
+
+ # Do them back to front, so our argc modifications will work
+ # correctly, because we examine trailing arguments first.
+ argConversions.reverse()
+ # Wrap each one in a scope so that any locals it has don't leak out, and
+ # also so that we can just "break;" for our successCode.
+ argConversions = [CGWrapper(CGIndenter(CGGeneric(c)),
+ pre="do {\n",
+ post="} while (0);\n")
+ for c in argConversions]
+ if self.argCount > 0:
+ argConversions.insert(0, self.getArgcDecl())
+ # And slap them together.
+ return CGList(argConversions, "\n").define() + "\n"
+
+ def getArgConversion(self, i, arg):
+ argval = arg.identifier.name
+
+ if arg.variadic:
+ argval = argval + "[idx]"
+ jsvalIndex = "%d + idx" % i
+ else:
+ jsvalIndex = "%d" % i
+ if arg.canHaveMissingValue():
+ argval += ".Value()"
+ if arg.type.isDOMString():
+ # XPConnect string-to-JS conversion wants to mutate the string. So
+ # let's give it a string it can mutate
+ # XXXbz if we try to do a sequence of strings, this will kinda fail.
+ result = "mutableStr"
+ prepend = "nsString mutableStr(%s);\n" % argval
+ else:
+ result = argval
+ prepend = ""
+
+ try:
+ conversion = prepend + wrapForType(
+ arg.type, self.descriptorProvider,
+ {
+ 'result': result,
+ 'successCode': "continue;\n" if arg.variadic else "break;\n",
+ 'jsvalRef': "argv[%s]" % jsvalIndex,
+ 'jsvalHandle': "argv[%s]" % jsvalIndex,
+ 'obj': self.wrapScope,
+ 'returnsNewObject': False,
+ 'exceptionCode': self.exceptionCode,
+ 'typedArraysAreStructs': self.typedArraysAreStructs
+ })
+ except MethodNotNewObjectError as err:
+ raise TypeError("%s being passed as an argument to %s but is not "
+ "wrapper cached, so can't be reliably converted to "
+ "a JS object." %
+ (err.typename, self.getPrettyName()))
+ if arg.variadic:
+ conversion = fill(
+ """
+ for (uint32_t idx = 0; idx < ${arg}.Length(); ++idx) {
+ $*{conversion}
+ }
+ break;
+ """,
+ arg=arg.identifier.name,
+ conversion=conversion)
+ elif arg.canHaveMissingValue():
+ conversion = fill(
+ """
+ if (${argName}.WasPassed()) {
+ $*{conversion}
+ } else if (argc == ${iPlus1}) {
+ // This is our current trailing argument; reduce argc
+ --argc;
+ } else {
+ argv[${i}].setUndefined();
+ }
+ """,
+ argName=arg.identifier.name,
+ conversion=conversion,
+ iPlus1=i + 1,
+ i=i)
+ return conversion
+
+ def getDefaultRetval(self):
+ default = self.getRetvalInfo(self.retvalType, False)[1]
+ if len(default) != 0:
+ default = " " + default
+ return default
+
+ def getArgs(self, returnType, argList):
+ args = CGNativeMember.getArgs(self, returnType, argList)
+ if not self.needThisHandling:
+ # Since we don't need this handling, we're the actual method that
+ # will be called, so we need an aRethrowExceptions argument.
+ if not self.rethrowContentException:
+ args.append(Argument("const char*", "aExecutionReason",
+ "nullptr"))
+ args.append(Argument("ExceptionHandling", "aExceptionHandling",
+ "eReportExceptions"))
+ args.append(Argument("JSCompartment*", "aCompartment", "nullptr"))
+ return args
+ # We want to allow the caller to pass in a "this" value, as
+ # well as a JSContext.
+ return [Argument("JSContext*", "cx"),
+ Argument("JS::Handle<JS::Value>", "aThisVal")] + args
+
+ def getCallSetup(self):
+ if self.needThisHandling:
+ # It's been done for us already
+ return ""
+ callSetup = "CallSetup s(this, aRv"
+ if self.rethrowContentException:
+ # getArgs doesn't add the aExceptionHandling argument but does add
+ # aCompartment for us.
+ callSetup += ', "%s", eRethrowContentExceptions, aCompartment, /* aIsJSImplementedWebIDL = */ ' % self.getPrettyName()
+ callSetup += toStringBool(isJSImplementedDescriptor(self.descriptorProvider))
+ else:
+ callSetup += ', "%s", aExceptionHandling, aCompartment' % self.getPrettyName()
+ callSetup += ");\n"
+ return fill(
+ """
+ $*{callSetup}
+ JSContext* cx = s.GetContext();
+ if (!cx) {
+ MOZ_ASSERT(aRv.Failed());
+ return${errorReturn};
+ }
+ """,
+ callSetup=callSetup,
+ errorReturn=self.getDefaultRetval())
+
+ def getArgcDecl(self):
+ return CGGeneric("unsigned argc = %s;\n" % self.argCountStr)
+
+ @staticmethod
+ def ensureASCIIName(idlObject):
+ type = "attribute" if idlObject.isAttr() else "operation"
+ if re.match("[^\x20-\x7E]", idlObject.identifier.name):
+ raise SyntaxError('Callback %s name "%s" contains non-ASCII '
+ "characters. We can't handle that. %s" %
+ (type, idlObject.identifier.name,
+ idlObject.location))
+ if re.match('"', idlObject.identifier.name):
+ raise SyntaxError("Callback %s name '%s' contains "
+ "double-quote character. We can't handle "
+ "that. %s" %
+ (type, idlObject.identifier.name,
+ idlObject.location))
+
+
+class CallbackMethod(CallbackMember):
+ def __init__(self, sig, name, descriptorProvider, needThisHandling,
+ rethrowContentException=False, typedArraysAreStructs=False):
+ CallbackMember.__init__(self, sig, name, descriptorProvider,
+ needThisHandling, rethrowContentException,
+ typedArraysAreStructs=typedArraysAreStructs)
+
+ def getRvalDecl(self):
+ return "JS::Rooted<JS::Value> rval(cx, JS::UndefinedValue());\n"
+
+ def getCall(self):
+ if self.argCount > 0:
+ args = "JS::HandleValueArray::subarray(argv, 0, argc)"
+ else:
+ args = "JS::HandleValueArray::empty()"
+
+ return fill(
+ """
+ $*{declCallable}
+ $*{declThis}
+ if (${callGuard}!JS::Call(cx, ${thisVal}, callable,
+ ${args}, &rval)) {
+ aRv.NoteJSContextException(cx);
+ return${errorReturn};
+ }
+ """,
+ declCallable=self.getCallableDecl(),
+ declThis=self.getThisDecl(),
+ callGuard=self.getCallGuard(),
+ thisVal=self.getThisVal(),
+ args=args,
+ errorReturn=self.getDefaultRetval())
+
+
+class CallCallback(CallbackMethod):
+ def __init__(self, callback, descriptorProvider):
+ self.callback = callback
+ CallbackMethod.__init__(self, callback.signatures()[0], "Call",
+ descriptorProvider, needThisHandling=True)
+
+ def getThisDecl(self):
+ return ""
+
+ def getThisVal(self):
+ return "aThisVal"
+
+ def getCallableDecl(self):
+ return "JS::Rooted<JS::Value> callable(cx, JS::ObjectValue(*mCallback));\n"
+
+ def getPrettyName(self):
+ return self.callback.identifier.name
+
+ def getCallGuard(self):
+ if self.callback._treatNonObjectAsNull:
+ return "JS::IsCallable(mCallback) && "
+ return ""
+
+
+class CallbackOperationBase(CallbackMethod):
+ """
+ Common class for implementing various callback operations.
+ """
+ def __init__(self, signature, jsName, nativeName, descriptor,
+ singleOperation, rethrowContentException=False,
+ typedArraysAreStructs=False):
+ self.singleOperation = singleOperation
+ self.methodName = descriptor.binaryNameFor(jsName)
+ CallbackMethod.__init__(self, signature, nativeName, descriptor,
+ singleOperation, rethrowContentException,
+ typedArraysAreStructs=typedArraysAreStructs)
+
+ def getThisDecl(self):
+ if not self.singleOperation:
+ return "JS::Rooted<JS::Value> thisValue(cx, JS::ObjectValue(*mCallback));\n"
+ # This relies on getCallableDecl declaring a boolean
+ # isCallable in the case when we're a single-operation
+ # interface.
+ return dedent("""
+ JS::Rooted<JS::Value> thisValue(cx, isCallable ? aThisVal.get()
+ : JS::ObjectValue(*mCallback));
+ """)
+
+ def getThisVal(self):
+ return "thisValue"
+
+ def getCallableDecl(self):
+ getCallableFromProp = fill(
+ """
+ ${atomCacheName}* atomsCache = GetAtomCache<${atomCacheName}>(cx);
+ if ((!*reinterpret_cast<jsid**>(atomsCache) && !InitIds(cx, atomsCache)) ||
+ !GetCallableProperty(cx, atomsCache->${methodAtomName}, &callable)) {
+ aRv.Throw(NS_ERROR_UNEXPECTED);
+ return${errorReturn};
+ }
+ """,
+ methodAtomName=CGDictionary.makeIdName(self.methodName),
+ atomCacheName=self.descriptorProvider.interface.identifier.name + "Atoms",
+ errorReturn=self.getDefaultRetval())
+ if not self.singleOperation:
+ return 'JS::Rooted<JS::Value> callable(cx);\n' + getCallableFromProp
+ return fill(
+ """
+ bool isCallable = JS::IsCallable(mCallback);
+ JS::Rooted<JS::Value> callable(cx);
+ if (isCallable) {
+ callable = JS::ObjectValue(*mCallback);
+ } else {
+ $*{getCallableFromProp}
+ }
+ """,
+ getCallableFromProp=getCallableFromProp)
+
+ def getCallGuard(self):
+ return ""
+
+
+class CallbackOperation(CallbackOperationBase):
+ """
+ Codegen actual WebIDL operations on callback interfaces.
+ """
+ def __init__(self, method, signature, descriptor, typedArraysAreStructs):
+ self.ensureASCIIName(method)
+ self.method = method
+ jsName = method.identifier.name
+ CallbackOperationBase.__init__(self, signature,
+ jsName,
+ MakeNativeName(descriptor.binaryNameFor(jsName)),
+ descriptor, descriptor.interface.isSingleOperationInterface(),
+ rethrowContentException=descriptor.interface.isJSImplemented(),
+ typedArraysAreStructs=typedArraysAreStructs)
+
+ def getPrettyName(self):
+ return "%s.%s" % (self.descriptorProvider.interface.identifier.name,
+ self.method.identifier.name)
+
+
+class CallbackAccessor(CallbackMember):
+ """
+ Shared superclass for CallbackGetter and CallbackSetter.
+ """
+ def __init__(self, attr, sig, name, descriptor, typedArraysAreStructs):
+ self.ensureASCIIName(attr)
+ self.attrName = attr.identifier.name
+ CallbackMember.__init__(self, sig, name, descriptor,
+ needThisHandling=False,
+ rethrowContentException=descriptor.interface.isJSImplemented(),
+ typedArraysAreStructs=typedArraysAreStructs)
+
+ def getPrettyName(self):
+ return "%s.%s" % (self.descriptorProvider.interface.identifier.name,
+ self.attrName)
+
+
+class CallbackGetter(CallbackAccessor):
+ def __init__(self, attr, descriptor, typedArraysAreStructs):
+ CallbackAccessor.__init__(self, attr,
+ (attr.type, []),
+ callbackGetterName(attr, descriptor),
+ descriptor,
+ typedArraysAreStructs)
+
+ def getRvalDecl(self):
+ return "JS::Rooted<JS::Value> rval(cx, JS::UndefinedValue());\n"
+
+ def getCall(self):
+ return fill(
+ """
+ JS::Rooted<JSObject *> callback(cx, mCallback);
+ ${atomCacheName}* atomsCache = GetAtomCache<${atomCacheName}>(cx);
+ if ((!*reinterpret_cast<jsid**>(atomsCache) && !InitIds(cx, atomsCache)) ||
+ !JS_GetPropertyById(cx, callback, atomsCache->${attrAtomName}, &rval)) {
+ aRv.Throw(NS_ERROR_UNEXPECTED);
+ return${errorReturn};
+ }
+ """,
+ atomCacheName=self.descriptorProvider.interface.identifier.name + "Atoms",
+ attrAtomName=CGDictionary.makeIdName(self.descriptorProvider.binaryNameFor(self.attrName)),
+ errorReturn=self.getDefaultRetval())
+
+
+class CallbackSetter(CallbackAccessor):
+ def __init__(self, attr, descriptor, typedArraysAreStructs):
+ CallbackAccessor.__init__(self, attr,
+ (BuiltinTypes[IDLBuiltinType.Types.void],
+ [FakeArgument(attr.type, attr)]),
+ callbackSetterName(attr, descriptor),
+ descriptor, typedArraysAreStructs)
+
+ def getRvalDecl(self):
+ # We don't need an rval
+ return ""
+
+ def getCall(self):
+ return fill(
+ """
+ MOZ_ASSERT(argv.length() == 1);
+ ${atomCacheName}* atomsCache = GetAtomCache<${atomCacheName}>(cx);
+ if ((!*reinterpret_cast<jsid**>(atomsCache) && !InitIds(cx, atomsCache)) ||
+ !JS_SetPropertyById(cx, CallbackKnownNotGray(), atomsCache->${attrAtomName}, argv[0])) {
+ aRv.Throw(NS_ERROR_UNEXPECTED);
+ return${errorReturn};
+ }
+ """,
+ atomCacheName=self.descriptorProvider.interface.identifier.name + "Atoms",
+ attrAtomName=CGDictionary.makeIdName(self.descriptorProvider.binaryNameFor(self.attrName)),
+ errorReturn=self.getDefaultRetval())
+
+ def getArgcDecl(self):
+ return None
+
+
+class CGJSImplInitOperation(CallbackOperationBase):
+ """
+ Codegen the __Init() method used to pass along constructor arguments for JS-implemented WebIDL.
+ """
+ def __init__(self, sig, descriptor):
+ assert sig in descriptor.interface.ctor().signatures()
+ CallbackOperationBase.__init__(self, (BuiltinTypes[IDLBuiltinType.Types.void], sig[1]),
+ "__init", "__Init", descriptor,
+ singleOperation=False,
+ rethrowContentException=True,
+ typedArraysAreStructs=True)
+
+ def getPrettyName(self):
+ return "__init"
+
+
+def getMaplikeOrSetlikeErrorReturn(helperImpl):
+ """
+ Generate return values based on whether a maplike or setlike generated
+ method is an interface method (which returns bool) or a helper function
+ (which uses ErrorResult).
+ """
+ if helperImpl:
+ return dedent(
+ """
+ aRv.Throw(NS_ERROR_UNEXPECTED);
+ return%s;
+ """ % helperImpl.getDefaultRetval())
+ return "return false;\n"
+
+
+def getMaplikeOrSetlikeBackingObject(descriptor, maplikeOrSetlike, helperImpl=None):
+ """
+ Generate code to get/create a JS backing object for a maplike/setlike
+ declaration from the declaration slot.
+ """
+ func_prefix = maplikeOrSetlike.maplikeOrSetlikeOrIterableType.title()
+ ret = fill(
+ """
+ JS::Rooted<JSObject*> backingObj(cx);
+ bool created = false;
+ if (!Get${func_prefix}BackingObject(cx, obj, ${slot}, &backingObj, &created)) {
+ $*{errorReturn}
+ }
+ if (created) {
+ PreserveWrapper<${selfType}>(self);
+ }
+ """,
+ slot=memberReservedSlot(maplikeOrSetlike, descriptor),
+ func_prefix=func_prefix,
+ errorReturn=getMaplikeOrSetlikeErrorReturn(helperImpl),
+ selfType=descriptor.nativeType)
+ return ret
+
+
+def getMaplikeOrSetlikeSizeGetterBody(descriptor, attr):
+ """
+ Creates the body for the size getter method of maplike/setlike interfaces.
+ """
+ # We should only have one declaration attribute currently
+ assert attr.identifier.name == "size"
+ assert attr.isMaplikeOrSetlikeAttr()
+ return fill(
+ """
+ $*{getBackingObj}
+ uint32_t result = JS::${funcPrefix}Size(cx, backingObj);
+ MOZ_ASSERT(!JS_IsExceptionPending(cx));
+ args.rval().setNumber(result);
+ return true;
+ """,
+ getBackingObj=getMaplikeOrSetlikeBackingObject(descriptor,
+ attr.maplikeOrSetlike),
+ funcPrefix=attr.maplikeOrSetlike.prefix)
+
+
+class CGMaplikeOrSetlikeMethodGenerator(CGThing):
+ """
+ Creates methods for maplike/setlike interfaces. It is expected that all
+ methods will be have a maplike/setlike object attached. Unwrapping/wrapping
+ will be taken care of by the usual method generation machinery in
+ CGMethodCall/CGPerSignatureCall. Functionality is filled in here instead of
+ using CGCallGenerator.
+ """
+ def __init__(self, descriptor, maplikeOrSetlike, methodName,
+ helperImpl=None):
+ CGThing.__init__(self)
+ # True if this will be the body of a C++ helper function.
+ self.helperImpl = helperImpl
+ self.descriptor = descriptor
+ self.maplikeOrSetlike = maplikeOrSetlike
+ self.cgRoot = CGList([])
+ impl_method_name = methodName
+ if impl_method_name[0] == "_":
+ # double underscore means this is a js-implemented chrome only rw
+ # function. Truncate the double underscore so calling the right
+ # underlying JSAPI function still works.
+ impl_method_name = impl_method_name[2:]
+ self.cgRoot.append(CGGeneric(
+ getMaplikeOrSetlikeBackingObject(self.descriptor,
+ self.maplikeOrSetlike,
+ self.helperImpl)))
+ self.returnStmt = getMaplikeOrSetlikeErrorReturn(self.helperImpl)
+
+ # Generates required code for the method. Method descriptions included
+ # in definitions below. Throw if we don't have a method to fill in what
+ # we're looking for.
+ try:
+ methodGenerator = getattr(self, impl_method_name)
+ except AttributeError:
+ raise TypeError("Missing %s method definition '%s'" %
+ (self.maplikeOrSetlike.maplikeOrSetlikeType,
+ methodName))
+ # Method generator returns tuple, containing:
+ #
+ # - a list of CGThings representing setup code for preparing to call
+ # the JS API function
+ # - a list of arguments needed for the JS API function we're calling
+ # - list of code CGThings needed for return value conversion.
+ (setupCode, arguments, setResult) = methodGenerator()
+
+ # Create the actual method call, and then wrap it with the code to
+ # return the value if needed.
+ funcName = (self.maplikeOrSetlike.prefix +
+ MakeNativeName(impl_method_name))
+ # Append the list of setup code CGThings
+ self.cgRoot.append(CGList(setupCode))
+ # Create the JS API call
+ self.cgRoot.append(CGWrapper(
+ CGGeneric(fill(
+ """
+ if (!JS::${funcName}(${args})) {
+ $*{errorReturn}
+ }
+ """,
+ funcName=funcName,
+ args=", ".join(["cx", "backingObj"] + arguments),
+ errorReturn=self.returnStmt))))
+ # Append result conversion
+ self.cgRoot.append(CGList(setResult))
+
+ def mergeTuples(self, a, b):
+ """
+ Expecting to take 2 tuples were all elements are lists, append the lists in
+ the second tuple to the lists in the first.
+ """
+ return tuple([x + y for x, y in zip(a, b)])
+
+ def appendArgConversion(self, name):
+ """
+ Generate code to convert arguments to JS::Values, so they can be
+ passed into JSAPI functions.
+ """
+ return CGGeneric(fill(
+ """
+ JS::Rooted<JS::Value> ${name}Val(cx);
+ if (!ToJSValue(cx, ${name}, &${name}Val)) {
+ $*{errorReturn}
+ }
+ """,
+ name=name,
+ errorReturn=self.returnStmt))
+
+ def appendKeyArgConversion(self):
+ """
+ Generates the key argument for methods. Helper functions will use
+ an AutoValueVector, while interface methods have seperate JS::Values.
+ """
+ if self.helperImpl:
+ return ([], ["argv[0]"], [])
+ return ([self.appendArgConversion("arg0")], ["arg0Val"], [])
+
+ def appendKeyAndValueArgConversion(self):
+ """
+ Generates arguments for methods that require a key and value. Helper
+ functions will use an AutoValueVector, while interface methods have
+ seperate JS::Values.
+ """
+ r = self.appendKeyArgConversion()
+ if self.helperImpl:
+ return self.mergeTuples(r, ([], ["argv[1]"], []))
+ return self.mergeTuples(r, ([self.appendArgConversion("arg1")],
+ ["arg1Val"],
+ []))
+
+ def appendIteratorResult(self):
+ """
+ Generate code to output JSObject* return values, needed for functions that
+ return iterators. Iterators cannot currently be wrapped via Xrays. If
+ something that would return an iterator is called via Xray, fail early.
+ """
+ # TODO: Bug 1173651 - Remove check once bug 1023984 is fixed.
+ code = CGGeneric(dedent(
+ """
+ // TODO (Bug 1173651): Xrays currently cannot wrap iterators. Change
+ // after bug 1023984 is fixed.
+ if (xpc::WrapperFactory::IsXrayWrapper(obj)) {
+ JS_ReportErrorASCII(cx, "Xray wrapping of iterators not supported.");
+ return false;
+ }
+ JS::Rooted<JSObject*> result(cx);
+ JS::Rooted<JS::Value> v(cx);
+ """))
+ arguments = "&v"
+ setResult = CGGeneric(dedent(
+ """
+ result = &v.toObject();
+ """))
+ return ([code], [arguments], [setResult])
+
+ def appendSelfResult(self):
+ """
+ Generate code to return the interface object itself.
+ """
+ code = CGGeneric(dedent(
+ """
+ JS::Rooted<JSObject*> result(cx);
+ """))
+ setResult = CGGeneric(dedent(
+ """
+ result = obj;
+ """))
+ return ([code], [], [setResult])
+
+ def appendBoolResult(self):
+ if self.helperImpl:
+ return ([CGGeneric()], ["&aRetVal"], [])
+ return ([CGGeneric("bool result;\n")], ["&result"], [])
+
+ def forEach(self):
+ """
+ void forEach(callback c, any thisval);
+
+ ForEach takes a callback, and a possible value to use as 'this'. The
+ callback needs to take value, key, and the interface object
+ implementing maplike/setlike. In order to make sure that the third arg
+ is our interface object instead of the map/set backing object, we
+ create a js function with the callback and original object in its
+ storage slots, then use a helper function in BindingUtils to make sure
+ the callback is called correctly.
+ """
+ assert(not self.helperImpl)
+ code = [CGGeneric(dedent(
+ """
+ // Create a wrapper function.
+ JSFunction* func = js::NewFunctionWithReserved(cx, ForEachHandler, 3, 0, nullptr);
+ if (!func) {
+ return false;
+ }
+ JS::Rooted<JSObject*> funcObj(cx, JS_GetFunctionObject(func));
+ JS::Rooted<JS::Value> funcVal(cx, JS::ObjectValue(*funcObj));
+ js::SetFunctionNativeReserved(funcObj, FOREACH_CALLBACK_SLOT,
+ JS::ObjectValue(*arg0));
+ js::SetFunctionNativeReserved(funcObj, FOREACH_MAPLIKEORSETLIKEOBJ_SLOT,
+ JS::ObjectValue(*obj));
+ """))]
+ arguments = ["funcVal", "arg1"]
+ return (code, arguments, [])
+
+ def set(self):
+ """
+ object set(key, value);
+
+ Maplike only function, takes key and sets value to it, returns
+ interface object unless being called from a C++ helper.
+ """
+ assert self.maplikeOrSetlike.isMaplike()
+ r = self.appendKeyAndValueArgConversion()
+ if self.helperImpl:
+ return r
+ return self.mergeTuples(r, self.appendSelfResult())
+
+ def add(self):
+ """
+ object add(value);
+
+ Setlike only function, adds value to set, returns interface object
+ unless being called from a C++ helper
+ """
+ assert self.maplikeOrSetlike.isSetlike()
+ r = self.appendKeyArgConversion()
+ if self.helperImpl:
+ return r
+ return self.mergeTuples(r, self.appendSelfResult())
+
+ def get(self):
+ """
+ type? get(key);
+
+ Retrieves a value from a backing object based on the key. Returns value
+ if key is in backing object, undefined otherwise.
+ """
+ assert self.maplikeOrSetlike.isMaplike()
+ r = self.appendKeyArgConversion()
+ code = [CGGeneric(dedent(
+ """
+ JS::Rooted<JS::Value> result(cx);
+ """))]
+ arguments = ["&result"]
+ return self.mergeTuples(r, (code, arguments, []))
+
+ def has(self):
+ """
+ bool has(key);
+
+ Check if an entry exists in the backing object. Returns true if value
+ exists in backing object, false otherwise.
+ """
+ return self.mergeTuples(self.appendKeyArgConversion(),
+ self.appendBoolResult())
+
+ def keys(self):
+ """
+ object keys();
+
+ Returns new object iterator with all keys from backing object.
+ """
+ return self.appendIteratorResult()
+
+ def values(self):
+ """
+ object values();
+
+ Returns new object iterator with all values from backing object.
+ """
+ return self.appendIteratorResult()
+
+ def entries(self):
+ """
+ object entries();
+
+ Returns new object iterator with all keys and values from backing
+ object. Keys will be null for set.
+ """
+ return self.appendIteratorResult()
+
+ def clear(self):
+ """
+ void clear();
+
+ Removes all entries from map/set.
+ """
+ return ([], [], [])
+
+ def delete(self):
+ """
+ bool delete(key);
+
+ Deletes an entry from the backing object. Returns true if value existed
+ in backing object, false otherwise.
+ """
+ return self.mergeTuples(self.appendKeyArgConversion(),
+ self.appendBoolResult())
+
+ def define(self):
+ return self.cgRoot.define()
+
+
+class CGMaplikeOrSetlikeHelperFunctionGenerator(CallbackMember):
+ """
+ Generates code to allow C++ to perform operations on backing objects. Gets
+ a context from the binding wrapper, turns arguments into JS::Values (via
+ CallbackMember/CGNativeMember argument conversion), then uses
+ CGMaplikeOrSetlikeMethodGenerator to generate the body.
+
+ """
+
+ class HelperFunction(CGAbstractMethod):
+ """
+ Generates context retrieval code and rooted JSObject for interface for
+ CGMaplikeOrSetlikeMethodGenerator to use
+ """
+ def __init__(self, descriptor, name, args, code, needsBoolReturn=False):
+ self.code = code
+ CGAbstractMethod.__init__(self, descriptor, name,
+ "bool" if needsBoolReturn else "void",
+ args)
+
+ def definition_body(self):
+ return self.code
+
+ def __init__(self, descriptor, maplikeOrSetlike, name, needsKeyArg=False,
+ needsValueArg=False, needsBoolReturn=False):
+ args = []
+ self.maplikeOrSetlike = maplikeOrSetlike
+ self.needsBoolReturn = needsBoolReturn
+ if needsKeyArg:
+ args.append(FakeArgument(maplikeOrSetlike.keyType, None, 'aKey'))
+ if needsValueArg:
+ assert needsKeyArg
+ args.append(FakeArgument(maplikeOrSetlike.valueType, None, 'aValue'))
+ # Run CallbackMember init function to generate argument conversion code.
+ # wrapScope is set to 'obj' when generating maplike or setlike helper
+ # functions, as we don't have access to the CallbackPreserveColor
+ # method.
+ CallbackMember.__init__(self,
+ [BuiltinTypes[IDLBuiltinType.Types.void], args],
+ name, descriptor, False,
+ wrapScope='obj')
+ # Wrap CallbackMember body code into a CGAbstractMethod to make
+ # generation easier.
+ self.implMethod = CGMaplikeOrSetlikeHelperFunctionGenerator.HelperFunction(
+ descriptor, name, self.args, self.body, needsBoolReturn)
+
+ def getCallSetup(self):
+ return dedent(
+ """
+ MOZ_ASSERT(self);
+ AutoJSAPI jsapi;
+ jsapi.Init();
+ JSContext* cx = jsapi.cx();
+ // It's safe to use UnprivilegedJunkScopeOrWorkerGlobal here because
+ // all we want is to wrap into _some_ scope and then unwrap to find
+ // the reflector, and wrapping has no side-effects.
+ JSAutoCompartment tempCompartment(cx, binding_detail::UnprivilegedJunkScopeOrWorkerGlobal());
+ JS::Rooted<JS::Value> v(cx);
+ if(!ToJSValue(cx, self, &v)) {
+ aRv.Throw(NS_ERROR_UNEXPECTED);
+ return%s;
+ }
+ // This is a reflector, but due to trying to name things
+ // similarly across method generators, it's called obj here.
+ JS::Rooted<JSObject*> obj(cx);
+ obj = js::UncheckedUnwrap(&v.toObject(), /* stopAtWindowProxy = */ false);
+ JSAutoCompartment reflectorCompartment(cx, obj);
+ """ % self.getDefaultRetval())
+
+ def getArgs(self, returnType, argList):
+ # We don't need the context or the value. We'll generate those instead.
+ args = CGNativeMember.getArgs(self, returnType, argList)
+ # Prepend a pointer to the binding object onto the arguments
+ return [Argument(self.descriptorProvider.nativeType + "*", "self")] + args
+
+ def getResultConversion(self):
+ if self.needsBoolReturn:
+ return "return aRetVal;\n"
+ return "return;\n"
+
+ def getRvalDecl(self):
+ if self.needsBoolReturn:
+ return "bool aRetVal;\n"
+ return ""
+
+ def getArgcDecl(self):
+ # Don't need argc for anything.
+ return None
+
+ def getDefaultRetval(self):
+ if self.needsBoolReturn:
+ return " false"
+ return ""
+
+ def getCall(self):
+ return CGMaplikeOrSetlikeMethodGenerator(self.descriptorProvider,
+ self.maplikeOrSetlike,
+ self.name.lower(),
+ helperImpl=self).define()
+
+ def getPrettyName(self):
+ return self.name
+
+ def declare(self):
+ return self.implMethod.declare()
+
+ def define(self):
+ return self.implMethod.define()
+
+
+class CGMaplikeOrSetlikeHelperGenerator(CGNamespace):
+ """
+ Declares and defines convenience methods for accessing backing objects on
+ setlike/maplike interface. Generates function signatures, un/packs
+ backing objects from slot, etc.
+ """
+ def __init__(self, descriptor, maplikeOrSetlike):
+ self.descriptor = descriptor
+ # Since iterables are folded in with maplike/setlike, make sure we've
+ # got the right type here.
+ assert maplikeOrSetlike.isMaplike() or maplikeOrSetlike.isSetlike()
+ self.maplikeOrSetlike = maplikeOrSetlike
+ self.namespace = "%sHelpers" % (self.maplikeOrSetlike.maplikeOrSetlikeOrIterableType.title())
+ self.helpers = [
+ CGMaplikeOrSetlikeHelperFunctionGenerator(descriptor,
+ maplikeOrSetlike,
+ "Clear"),
+ CGMaplikeOrSetlikeHelperFunctionGenerator(descriptor,
+ maplikeOrSetlike,
+ "Delete",
+ needsKeyArg=True,
+ needsBoolReturn=True),
+ CGMaplikeOrSetlikeHelperFunctionGenerator(descriptor,
+ maplikeOrSetlike,
+ "Has",
+ needsKeyArg=True,
+ needsBoolReturn=True)]
+ if self.maplikeOrSetlike.isMaplike():
+ self.helpers.append(
+ CGMaplikeOrSetlikeHelperFunctionGenerator(descriptor,
+ maplikeOrSetlike,
+ "Set",
+ needsKeyArg=True,
+ needsValueArg=True))
+ else:
+ assert(self.maplikeOrSetlike.isSetlike())
+ self.helpers.append(
+ CGMaplikeOrSetlikeHelperFunctionGenerator(descriptor,
+ maplikeOrSetlike,
+ "Add",
+ needsKeyArg=True))
+ CGNamespace.__init__(self, self.namespace, CGList(self.helpers))
+
+
+class CGIterableMethodGenerator(CGGeneric):
+ """
+ Creates methods for iterable interfaces. Unwrapping/wrapping
+ will be taken care of by the usual method generation machinery in
+ CGMethodCall/CGPerSignatureCall. Functionality is filled in here instead of
+ using CGCallGenerator.
+ """
+ def __init__(self, descriptor, iterable, methodName):
+ if methodName == "forEach":
+ CGGeneric.__init__(self, fill(
+ """
+ if (!JS::IsCallable(arg0)) {
+ ThrowErrorMessage(cx, MSG_NOT_CALLABLE, "Argument 1 of ${ifaceName}.forEach");
+ return false;
+ }
+ JS::AutoValueArray<3> callArgs(cx);
+ callArgs[2].setObject(*obj);
+ JS::Rooted<JS::Value> ignoredReturnVal(cx);
+ for (size_t i = 0; i < self->GetIterableLength(); ++i) {
+ if (!ToJSValue(cx, self->GetValueAtIndex(i), callArgs[0])) {
+ return false;
+ }
+ if (!ToJSValue(cx, self->GetKeyAtIndex(i), callArgs[1])) {
+ return false;
+ }
+ if (!JS::Call(cx, arg1, arg0, JS::HandleValueArray(callArgs),
+ &ignoredReturnVal)) {
+ return false;
+ }
+ }
+ """,
+ ifaceName=descriptor.interface.identifier.name))
+ return
+ CGGeneric.__init__(self, fill(
+ """
+ typedef ${iterClass} itrType;
+ RefPtr<itrType> result(new itrType(self,
+ itrType::IterableIteratorType::${itrMethod},
+ &${ifaceName}IteratorBinding::Wrap));
+ """,
+ iterClass=iteratorNativeType(descriptor),
+ ifaceName=descriptor.interface.identifier.name,
+ itrMethod=methodName.title()))
+
+
+class GlobalGenRoots():
+ """
+ Roots for global codegen.
+
+ To generate code, call the method associated with the target, and then
+ call the appropriate define/declare method.
+ """
+
+ @staticmethod
+ def GeneratedAtomList(config):
+ # Atom enum
+ dictionaries = config.dictionaries
+
+ structs = []
+
+ def memberToAtomCacheMember(binaryNameFor, m):
+ binaryMemberName = binaryNameFor(m.identifier.name)
+ return ClassMember(CGDictionary.makeIdName(binaryMemberName),
+ "PinnedStringId", visibility="public")
+
+ def buildAtomCacheStructure(idlobj, binaryNameFor, members):
+ classMembers = [memberToAtomCacheMember(binaryNameFor, m)
+ for m in members]
+ structName = idlobj.identifier.name + "Atoms"
+ return (structName,
+ CGWrapper(CGClass(structName,
+ bases=None,
+ isStruct=True,
+ members=classMembers), post='\n'))
+
+ for dict in dictionaries:
+ if len(dict.members) == 0:
+ continue
+
+ structs.append(buildAtomCacheStructure(dict, lambda x: x, dict.members))
+
+ for d in (config.getDescriptors(isJSImplemented=True) +
+ config.getDescriptors(isCallback=True)):
+ members = [m for m in d.interface.members if m.isAttr() or m.isMethod()]
+ if d.interface.isJSImplemented() and d.interface.ctor():
+ # We'll have an __init() method.
+ members.append(FakeMember('__init'))
+ if len(members) == 0:
+ continue
+
+ structs.append(buildAtomCacheStructure(d.interface,
+ lambda x: d.binaryNameFor(x),
+ members))
+
+ structs.sort()
+ generatedStructs = [struct for structName, struct in structs]
+ structNames = [structName for structName, struct in structs]
+
+ mainStruct = CGWrapper(CGClass("PerThreadAtomCache",
+ bases=[ClassBase(structName) for structName in structNames],
+ isStruct=True),
+ post='\n')
+
+ structs = CGList(generatedStructs + [mainStruct])
+
+ # Wrap all of that in our namespaces.
+ curr = CGNamespace.build(['mozilla', 'dom'],
+ CGWrapper(structs, pre='\n'))
+ curr = CGWrapper(curr, post='\n')
+
+ # Add include statement for PinnedStringId.
+ declareIncludes = ['mozilla/dom/BindingUtils.h']
+ curr = CGHeaders([], [], [], [], declareIncludes, [], 'GeneratedAtomList',
+ curr)
+
+ # Add include guards.
+ curr = CGIncludeGuard('GeneratedAtomList', curr)
+
+ # Add the auto-generated comment.
+ curr = CGWrapper(curr, pre=AUTOGENERATED_WARNING_COMMENT)
+
+ # Done.
+ return curr
+
+ @staticmethod
+ def GeneratedEventList(config):
+ eventList = CGList([])
+ for generatedEvent in config.generatedEvents:
+ eventList.append(CGGeneric(declare=("GENERATED_EVENT(%s)\n" % generatedEvent)))
+ return eventList
+
+ @staticmethod
+ def PrototypeList(config):
+
+ # Prototype ID enum.
+ descriptorsWithPrototype = config.getDescriptors(hasInterfacePrototypeObject=True)
+ protos = [d.name for d in descriptorsWithPrototype]
+ idEnum = CGNamespacedEnum('id', 'ID', ['_ID_Start'] + protos,
+ [0, '_ID_Start'])
+ idEnum = CGList([idEnum])
+
+ def fieldSizeAssert(amount, jitInfoField, message):
+ maxFieldValue = "(uint64_t(1) << (sizeof(((JSJitInfo*)nullptr)->%s) * 8))" % jitInfoField
+ return CGGeneric(declare="static_assert(%s < %s, \"%s\");\n\n"
+ % (amount, maxFieldValue, message))
+
+ idEnum.append(fieldSizeAssert("id::_ID_Count", "protoID",
+ "Too many prototypes!"))
+
+ # Wrap all of that in our namespaces.
+ idEnum = CGNamespace.build(['mozilla', 'dom', 'prototypes'],
+ CGWrapper(idEnum, pre='\n'))
+ idEnum = CGWrapper(idEnum, post='\n')
+
+ curr = CGList([CGGeneric(define="#include <stdint.h>\n\n"),
+ idEnum])
+
+ # Let things know the maximum length of the prototype chain.
+ maxMacroName = "MAX_PROTOTYPE_CHAIN_LENGTH"
+ maxMacro = CGGeneric(declare="#define " + maxMacroName + " " + str(config.maxProtoChainLength))
+ curr.append(CGWrapper(maxMacro, post='\n\n'))
+ curr.append(fieldSizeAssert(maxMacroName, "depth",
+ "Some inheritance chain is too long!"))
+
+ # Constructor ID enum.
+ constructors = [d.name for d in config.getDescriptors(hasInterfaceObject=True)]
+ idEnum = CGNamespacedEnum('id', 'ID', ['_ID_Start'] + constructors,
+ ['prototypes::id::_ID_Count', '_ID_Start'])
+
+ # Wrap all of that in our namespaces.
+ idEnum = CGNamespace.build(['mozilla', 'dom', 'constructors'],
+ CGWrapper(idEnum, pre='\n'))
+ idEnum = CGWrapper(idEnum, post='\n')
+
+ curr.append(idEnum)
+
+ # Named properties object enum.
+ namedPropertiesObjects = [d.name for d in config.getDescriptors(hasNamedPropertiesObject=True)]
+ idEnum = CGNamespacedEnum('id', 'ID', ['_ID_Start'] + namedPropertiesObjects,
+ ['constructors::id::_ID_Count', '_ID_Start'])
+
+ # Wrap all of that in our namespaces.
+ idEnum = CGNamespace.build(['mozilla', 'dom', 'namedpropertiesobjects'],
+ CGWrapper(idEnum, pre='\n'))
+ idEnum = CGWrapper(idEnum, post='\n')
+
+ curr.append(idEnum)
+
+ traitsDecls = [CGGeneric(declare=dedent("""
+ template <prototypes::ID PrototypeID>
+ struct PrototypeTraits;
+ """))]
+ traitsDecls.extend(CGPrototypeTraitsClass(d) for d in descriptorsWithPrototype)
+
+ ifaceNamesWithProto = [d.interface.identifier.name
+ for d in descriptorsWithPrototype]
+ traitsDecls.append(CGStringTable("NamesOfInterfacesWithProtos",
+ ifaceNamesWithProto))
+
+ traitsDecl = CGNamespace.build(['mozilla', 'dom'],
+ CGList(traitsDecls))
+
+ curr.append(traitsDecl)
+
+ # Add include guards.
+ curr = CGIncludeGuard('PrototypeList', curr)
+
+ # Add the auto-generated comment.
+ curr = CGWrapper(curr, pre=AUTOGENERATED_WARNING_COMMENT)
+
+ # Done.
+ return curr
+
+ @staticmethod
+ def RegisterBindings(config):
+
+ curr = CGList([CGGlobalNamesString(config), CGRegisterGlobalNames(config)])
+
+ # Wrap all of that in our namespaces.
+ curr = CGNamespace.build(['mozilla', 'dom'],
+ CGWrapper(curr, post='\n'))
+ curr = CGWrapper(curr, post='\n')
+
+ # Add the includes
+ defineIncludes = [CGHeaders.getDeclarationFilename(desc.interface)
+ for desc in config.getDescriptors(hasInterfaceObject=True,
+ isExposedInWindow=True,
+ register=True)]
+ defineIncludes.append('mozilla/dom/WebIDLGlobalNameHash.h')
+ defineIncludes.extend([CGHeaders.getDeclarationFilename(desc.interface)
+ for desc in config.getDescriptors(isNavigatorProperty=True,
+ register=True)])
+ curr = CGHeaders([], [], [], [], [], defineIncludes, 'RegisterBindings',
+ curr)
+
+ # Add include guards.
+ curr = CGIncludeGuard('RegisterBindings', curr)
+
+ # Done.
+ return curr
+
+ @staticmethod
+ def RegisterWorkerBindings(config):
+
+ curr = CGRegisterWorkerBindings(config)
+
+ # Wrap all of that in our namespaces.
+ curr = CGNamespace.build(['mozilla', 'dom'],
+ CGWrapper(curr, post='\n'))
+ curr = CGWrapper(curr, post='\n')
+
+ # Add the includes
+ defineIncludes = [CGHeaders.getDeclarationFilename(desc.interface)
+ for desc in config.getDescriptors(hasInterfaceObject=True,
+ register=True,
+ isExposedInAnyWorker=True)]
+
+ curr = CGHeaders([], [], [], [], [], defineIncludes,
+ 'RegisterWorkerBindings', curr)
+
+ # Add include guards.
+ curr = CGIncludeGuard('RegisterWorkerBindings', curr)
+
+ # Done.
+ return curr
+
+ @staticmethod
+ def RegisterWorkerDebuggerBindings(config):
+
+ curr = CGRegisterWorkerDebuggerBindings(config)
+
+ # Wrap all of that in our namespaces.
+ curr = CGNamespace.build(['mozilla', 'dom'],
+ CGWrapper(curr, post='\n'))
+ curr = CGWrapper(curr, post='\n')
+
+ # Add the includes
+ defineIncludes = [CGHeaders.getDeclarationFilename(desc.interface)
+ for desc in config.getDescriptors(hasInterfaceObject=True,
+ register=True,
+ isExposedInWorkerDebugger=True)]
+
+ curr = CGHeaders([], [], [], [], [], defineIncludes,
+ 'RegisterWorkerDebuggerBindings', curr)
+
+ # Add include guards.
+ curr = CGIncludeGuard('RegisterWorkerDebuggerBindings', curr)
+
+ # Done.
+ return curr
+
+ @staticmethod
+ def RegisterWorkletBindings(config):
+
+ curr = CGRegisterWorkletBindings(config)
+
+ # Wrap all of that in our namespaces.
+ curr = CGNamespace.build(['mozilla', 'dom'],
+ CGWrapper(curr, post='\n'))
+ curr = CGWrapper(curr, post='\n')
+
+ # Add the includes
+ defineIncludes = [CGHeaders.getDeclarationFilename(desc.interface)
+ for desc in config.getDescriptors(hasInterfaceObject=True,
+ register=True,
+ isExposedInAnyWorklet=True)]
+
+ curr = CGHeaders([], [], [], [], [], defineIncludes,
+ 'RegisterWorkletBindings', curr)
+
+ # Add include guards.
+ curr = CGIncludeGuard('RegisterWorkletBindings', curr)
+
+ # Done.
+ return curr
+
+ @staticmethod
+ def ResolveSystemBinding(config):
+
+ curr = CGResolveSystemBinding(config)
+
+ # Wrap all of that in our namespaces.
+ curr = CGNamespace.build(['mozilla', 'dom'],
+ CGWrapper(curr, post='\n'))
+ curr = CGWrapper(curr, post='\n')
+
+ # Add the includes
+ defineIncludes = [CGHeaders.getDeclarationFilename(desc.interface)
+ for desc in config.getDescriptors(hasInterfaceObject=True,
+ register=True,
+ isExposedInSystemGlobals=True)]
+ defineIncludes.append("nsThreadUtils.h") # For NS_IsMainThread
+ defineIncludes.append("js/Id.h") # For jsid
+ defineIncludes.append("mozilla/dom/BindingUtils.h") # AtomizeAndPinJSString
+
+ curr = CGHeaders([], [], [], [], [], defineIncludes,
+ 'ResolveSystemBinding', curr)
+
+ # Add include guards.
+ curr = CGIncludeGuard('ResolveSystemBinding', curr)
+
+ # Done.
+ return curr
+
+ @staticmethod
+ def UnionTypes(config):
+ unionTypes = UnionsForFile(config, None)
+ (includes, implincludes, declarations,
+ traverseMethods, unlinkMethods,
+ unionStructs) = UnionTypes(unionTypes, config)
+
+ unions = CGList(traverseMethods +
+ unlinkMethods +
+ [CGUnionStruct(t, config) for t in unionStructs] +
+ [CGUnionStruct(t, config, True) for t in unionStructs],
+ "\n")
+
+ includes.add("mozilla/OwningNonNull.h")
+ includes.add("mozilla/dom/UnionMember.h")
+ includes.add("mozilla/dom/BindingDeclarations.h")
+ # BindingUtils.h is only needed for SetToObject.
+ # If it stops being inlined or stops calling CallerSubsumes
+ # both this bit and the bit in CGBindingRoot can be removed.
+ includes.add("mozilla/dom/BindingUtils.h")
+ implincludes.add("mozilla/dom/PrimitiveConversions.h")
+
+ # Wrap all of that in our namespaces.
+ curr = CGNamespace.build(['mozilla', 'dom'], unions)
+
+ curr = CGWrapper(curr, post='\n')
+
+ builder = ForwardDeclarationBuilder()
+ for className, isStruct in declarations:
+ builder.add(className, isStruct=isStruct)
+
+ curr = CGList([builder.build(), curr], "\n")
+
+ curr = CGHeaders([], [], [], [], includes, implincludes, 'UnionTypes',
+ curr)
+
+ # Add include guards.
+ curr = CGIncludeGuard('UnionTypes', curr)
+
+ # Done.
+ return curr
+
+ @staticmethod
+ def UnionConversions(config):
+ unionTypes = []
+ for l in config.unionsPerFilename.itervalues():
+ unionTypes.extend(l)
+ unionTypes.sort(key=lambda u: u.name)
+ headers, unions = UnionConversions(unionTypes,
+ config)
+
+ # Wrap all of that in our namespaces.
+ curr = CGNamespace.build(['mozilla', 'dom'], unions)
+
+ curr = CGWrapper(curr, post='\n')
+
+ headers.update(["nsDebug.h", "mozilla/dom/UnionTypes.h"])
+ curr = CGHeaders([], [], [], [], headers, [], 'UnionConversions', curr)
+
+ # Add include guards.
+ curr = CGIncludeGuard('UnionConversions', curr)
+
+ # Done.
+ return curr
+
+
+# Code generator for simple events
+class CGEventGetter(CGNativeMember):
+ def __init__(self, descriptor, attr):
+ ea = descriptor.getExtendedAttributes(attr, getter=True)
+ CGNativeMember.__init__(self, descriptor, attr,
+ CGSpecializedGetter.makeNativeName(descriptor,
+ attr),
+ (attr.type, []),
+ ea,
+ resultNotAddRefed=not attr.type.isSequence())
+ self.body = self.getMethodBody()
+
+ def getArgs(self, returnType, argList):
+ if 'infallible' not in self.extendedAttrs:
+ raise TypeError("Event code generator does not support [Throws]!")
+ if not self.member.isAttr():
+ raise TypeError("Event code generator does not support methods")
+ if self.member.isStatic():
+ raise TypeError("Event code generators does not support static attributes")
+ return CGNativeMember.getArgs(self, returnType, argList)
+
+ def getMethodBody(self):
+ type = self.member.type
+ memberName = CGDictionary.makeMemberName(self.member.identifier.name)
+ if (type.isPrimitive() and type.tag() in builtinNames) or type.isEnum() or type.isGeckoInterface():
+ return "return " + memberName + ";\n"
+ if type.isDOMString() or type.isByteString() or type.isUSVString():
+ return "aRetVal = " + memberName + ";\n"
+ if type.isSpiderMonkeyInterface() or type.isObject():
+ return fill(
+ """
+ if (${memberName}) {
+ JS::ExposeObjectToActiveJS(${memberName});
+ }
+ aRetVal.set(${memberName});
+ return;
+ """,
+ memberName=memberName)
+ if type.isAny():
+ return fill(
+ """
+ ${selfName}(aRetVal);
+ """,
+ selfName=self.name)
+ if type.isUnion():
+ return "aRetVal = " + memberName + ";\n"
+ if type.isSequence():
+ return "aRetVal = " + memberName + ";\n"
+ raise TypeError("Event code generator does not support this type!")
+
+ def declare(self, cgClass):
+ if getattr(self.member, "originatingInterface",
+ cgClass.descriptor.interface) != cgClass.descriptor.interface:
+ return ""
+ return CGNativeMember.declare(self, cgClass)
+
+ def define(self, cgClass):
+ if getattr(self.member, "originatingInterface",
+ cgClass.descriptor.interface) != cgClass.descriptor.interface:
+ return ""
+ return CGNativeMember.define(self, cgClass)
+
+
+class CGEventSetter(CGNativeMember):
+ def __init__(self):
+ raise TypeError("Event code generator does not support setters!")
+
+
+class CGEventMethod(CGNativeMember):
+ def __init__(self, descriptor, method, signature, isConstructor, breakAfter=True):
+ self.isInit = False
+
+ CGNativeMember.__init__(self, descriptor, method,
+ CGSpecializedMethod.makeNativeName(descriptor,
+ method),
+ signature,
+ descriptor.getExtendedAttributes(method),
+ breakAfter=breakAfter,
+ variadicIsSequence=True)
+ self.originalArgs = list(self.args)
+
+ iface = descriptor.interface
+ allowed = isConstructor
+ if not allowed and iface.getExtendedAttribute("LegacyEventInit"):
+ # Allow it, only if it fits the initFooEvent profile exactly
+ # We could check the arg types but it's not worth the effort.
+ if (method.identifier.name == "init" + iface.identifier.name and
+ signature[1][0].type.isDOMString() and
+ signature[1][1].type.isBoolean() and
+ signature[1][2].type.isBoolean() and
+ # -3 on the left to ignore the type, bubbles, and cancelable parameters
+ # -1 on the right to ignore the .trusted property which bleeds through
+ # here because it is [Unforgeable].
+ len(signature[1]) - 3 == len(filter(lambda x: x.isAttr(), iface.members)) - 1):
+ allowed = True
+ self.isInit = True
+
+ if not allowed:
+ raise TypeError("Event code generator does not support methods!")
+
+ def getArgs(self, returnType, argList):
+ args = [self.getArg(arg) for arg in argList]
+ return args
+
+ def getArg(self, arg):
+ decl, ref = self.getArgType(arg.type,
+ arg.canHaveMissingValue(),
+ "Variadic" if arg.variadic else False)
+ if ref:
+ decl = CGWrapper(decl, pre="const ", post="&")
+
+ name = arg.identifier.name
+ name = "a" + name[0].upper() + name[1:]
+ return Argument(decl.define(), name)
+
+ def declare(self, cgClass):
+ if self.isInit:
+ constructorForNativeCaller = ""
+ else:
+ self.args = list(self.originalArgs)
+ self.args.insert(0, Argument("mozilla::dom::EventTarget*", "aOwner"))
+ constructorForNativeCaller = CGNativeMember.declare(self, cgClass)
+
+ self.args = list(self.originalArgs)
+ if needCx(None, self.arguments(), [], considerTypes=True, static=True):
+ self.args.insert(0, Argument("JSContext*", "aCx"))
+ if not self.isInit:
+ self.args.insert(0, Argument("const GlobalObject&", "aGlobal"))
+ self.args.append(Argument('ErrorResult&', 'aRv'))
+ return constructorForNativeCaller + CGNativeMember.declare(self, cgClass)
+
+ def defineInit(self, cgClass):
+ iface = self.descriptorProvider.interface
+ members = ""
+ while iface.identifier.name != "Event":
+ i = 3 # Skip the boilerplate args: type, bubble,s cancelable.
+ for m in iface.members:
+ if m.isAttr():
+ # We need to initialize all the member variables that do
+ # not come from Event.
+ if getattr(m, "originatingInterface",
+ iface).identifier.name == "Event":
+ continue
+ name = CGDictionary.makeMemberName(m.identifier.name)
+ members += "%s = %s;\n" % (name, self.args[i].name)
+ i += 1
+ iface = iface.parent
+
+ self.body = fill(
+ """
+ InitEvent(${typeArg}, ${bubblesArg}, ${cancelableArg});
+ ${members}
+ """,
+ typeArg=self.args[0].name,
+ bubblesArg=self.args[1].name,
+ cancelableArg=self.args[2].name,
+ members=members)
+
+ return CGNativeMember.define(self, cgClass)
+
+ def define(self, cgClass):
+ self.args = list(self.originalArgs)
+ if self.isInit:
+ return self.defineInit(cgClass)
+ members = ""
+ holdJS = ""
+ iface = self.descriptorProvider.interface
+ while iface.identifier.name != "Event":
+ for m in self.descriptorProvider.getDescriptor(iface.identifier.name).interface.members:
+ if m.isAttr():
+ # We initialize all the other member variables in the
+ # Constructor except those ones coming from the Event.
+ if getattr(m, "originatingInterface",
+ cgClass.descriptor.interface).identifier.name == "Event":
+ continue
+ name = CGDictionary.makeMemberName(m.identifier.name)
+ if m.type.isSequence():
+ # For sequences we may not be able to do a simple
+ # assignment because the underlying types may not match.
+ # For example, the argument can be a
+ # Sequence<OwningNonNull<SomeInterface>> while our
+ # member is an nsTArray<RefPtr<SomeInterface>>. So
+ # use AppendElements, which is actually a template on
+ # the incoming type on nsTArray and does the right thing
+ # for this case.
+ target = name
+ source = "%s.%s" % (self.args[1].name, name)
+ sequenceCopy = "e->%s.AppendElements(%s);\n"
+ if m.type.nullable():
+ sequenceCopy = CGIfWrapper(
+ CGGeneric(sequenceCopy),
+ "!%s.IsNull()" % source).define()
+ target += ".SetValue()"
+ source += ".Value()"
+ members += sequenceCopy % (target, source)
+ elif m.type.isSpiderMonkeyInterface():
+ srcname = "%s.%s" % (self.args[1].name, name)
+ if m.type.nullable():
+ members += fill(
+ """
+ if (${srcname}.IsNull()) {
+ e->${varname} = nullptr;
+ } else {
+ e->${varname} = ${srcname}.Value().Obj();
+ }
+ """,
+ varname=name,
+ srcname=srcname)
+ else:
+ members += fill(
+ """
+ e->${varname}.set(${srcname}.Obj());
+ """,
+ varname=name, srcname=srcname)
+ else:
+ members += "e->%s = %s.%s;\n" % (name, self.args[1].name, name)
+ if m.type.isAny() or m.type.isObject() or m.type.isSpiderMonkeyInterface():
+ holdJS = "mozilla::HoldJSObjects(e.get());\n"
+ iface = iface.parent
+
+ self.body = fill(
+ """
+ RefPtr<${nativeType}> e = new ${nativeType}(aOwner);
+ bool trusted = e->Init(aOwner);
+ e->InitEvent(${eventType}, ${eventInit}.mBubbles, ${eventInit}.mCancelable);
+ $*{members}
+ e->SetTrusted(trusted);
+ e->SetComposed(${eventInit}.mComposed);
+ $*{holdJS}
+ return e.forget();
+ """,
+ nativeType=self.descriptorProvider.nativeType.split('::')[-1],
+ eventType=self.args[0].name,
+ eventInit=self.args[1].name,
+ members=members,
+ holdJS=holdJS)
+
+ self.args.insert(0, Argument("mozilla::dom::EventTarget*", "aOwner"))
+ constructorForNativeCaller = CGNativeMember.define(self, cgClass) + "\n"
+ self.args = list(self.originalArgs)
+ self.body = fill(
+ """
+ nsCOMPtr<mozilla::dom::EventTarget> owner = do_QueryInterface(aGlobal.GetAsSupports());
+ return Constructor(owner, ${arg0}, ${arg1});
+ """,
+ arg0=self.args[0].name,
+ arg1=self.args[1].name)
+ if needCx(None, self.arguments(), [], considerTypes=True, static=True):
+ self.args.insert(0, Argument("JSContext*", "aCx"))
+ self.args.insert(0, Argument("const GlobalObject&", "aGlobal"))
+ self.args.append(Argument('ErrorResult&', 'aRv'))
+ return constructorForNativeCaller + CGNativeMember.define(self, cgClass)
+
+
+class CGEventClass(CGBindingImplClass):
+ """
+ Codegen for the actual Event class implementation for this descriptor
+ """
+ def __init__(self, descriptor):
+ CGBindingImplClass.__init__(self, descriptor, CGEventMethod, CGEventGetter, CGEventSetter, False, "WrapObjectInternal")
+ members = []
+ extraMethods = []
+ for m in descriptor.interface.members:
+ if m.isAttr():
+ if m.type.isAny():
+ # Add a getter that doesn't need a JSContext. Note that we
+ # don't need to do this if our originating interface is not
+ # the descriptor's interface, because in that case we
+ # wouldn't generate the getter that _does_ need a JSContext
+ # either.
+ extraMethods.append(
+ ClassMethod(
+ CGSpecializedGetter.makeNativeName(descriptor, m),
+ "void",
+ [Argument("JS::MutableHandle<JS::Value>",
+ "aRetVal")],
+ const=True,
+ body=fill(
+ """
+ JS::ExposeValueToActiveJS(${memberName});
+ aRetVal.set(${memberName});
+ """,
+ memberName=CGDictionary.makeMemberName(m.identifier.name))))
+ if getattr(m, "originatingInterface",
+ descriptor.interface) != descriptor.interface:
+ continue
+ nativeType = self.getNativeTypeForIDLType(m.type).define()
+ members.append(ClassMember(CGDictionary.makeMemberName(m.identifier.name),
+ nativeType,
+ visibility="private",
+ body="body"))
+
+ parent = self.descriptor.interface.parent
+ self.parentType = self.descriptor.getDescriptor(parent.identifier.name).nativeType.split('::')[-1]
+ baseDeclarations = fill(
+ """
+ public:
+ NS_DECL_ISUPPORTS_INHERITED
+ NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(${nativeType}, ${parentType})
+ protected:
+ virtual ~${nativeType}();
+ explicit ${nativeType}(mozilla::dom::EventTarget* aOwner);
+
+ """,
+ nativeType=self.descriptor.nativeType.split('::')[-1],
+ parentType=self.parentType)
+
+ className = descriptor.nativeType.split('::')[-1]
+ asConcreteTypeMethod = ClassMethod("As%s" % className,
+ "%s*" % className,
+ [],
+ virtual=True,
+ body="return this;\n",
+ breakAfterReturnDecl=" ",
+ override=True)
+ extraMethods.append(asConcreteTypeMethod)
+
+ CGClass.__init__(self, className,
+ bases=[ClassBase(self.parentType)],
+ methods=extraMethods+self.methodDecls,
+ members=members,
+ extradeclarations=baseDeclarations)
+
+ def getWrapObjectBody(self):
+ return "return %sBinding::Wrap(aCx, this, aGivenProto);\n" % self.descriptor.name
+
+ def implTraverse(self):
+ retVal = ""
+ for m in self.descriptor.interface.members:
+ # Unroll the type so we pick up sequences of interfaces too.
+ if m.isAttr() and idlTypeNeedsCycleCollection(m.type):
+ retVal += (" NS_IMPL_CYCLE_COLLECTION_TRAVERSE(" +
+ CGDictionary.makeMemberName(m.identifier.name) +
+ ")\n")
+ return retVal
+
+ def implUnlink(self):
+ retVal = ""
+ for m in self.descriptor.interface.members:
+ if m.isAttr():
+ name = CGDictionary.makeMemberName(m.identifier.name)
+ # Unroll the type so we pick up sequences of interfaces too.
+ if idlTypeNeedsCycleCollection(m.type):
+ retVal += " NS_IMPL_CYCLE_COLLECTION_UNLINK(" + name + ")\n"
+ elif m.type.isAny():
+ retVal += " tmp->" + name + ".setUndefined();\n"
+ elif m.type.isObject() or m.type.isSpiderMonkeyInterface():
+ retVal += " tmp->" + name + " = nullptr;\n"
+ return retVal
+
+ def implTrace(self):
+ retVal = ""
+ for m in self.descriptor.interface.members:
+ if m.isAttr():
+ name = CGDictionary.makeMemberName(m.identifier.name)
+ if m.type.isAny() or m.type.isObject() or m.type.isSpiderMonkeyInterface():
+ retVal += " NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(" + name + ")\n"
+ elif typeNeedsRooting(m.type):
+ raise TypeError("Need to implement tracing for event "
+ "member of type %s" % m.type)
+ return retVal
+
+ def define(self):
+ dropJS = ""
+ for m in self.descriptor.interface.members:
+ if m.isAttr():
+ member = CGDictionary.makeMemberName(m.identifier.name)
+ if m.type.isAny():
+ dropJS += member + " = JS::UndefinedValue();\n"
+ elif m.type.isObject() or m.type.isSpiderMonkeyInterface():
+ dropJS += member + " = nullptr;\n"
+ if dropJS != "":
+ dropJS += "mozilla::DropJSObjects(this);\n"
+ # Just override CGClass and do our own thing
+ nativeType = self.descriptor.nativeType.split('::')[-1]
+ ctorParams = ("aOwner, nullptr, nullptr" if self.parentType == "Event"
+ else "aOwner")
+
+ classImpl = fill(
+ """
+
+ NS_IMPL_CYCLE_COLLECTION_CLASS(${nativeType})
+
+ NS_IMPL_ADDREF_INHERITED(${nativeType}, ${parentType})
+ NS_IMPL_RELEASE_INHERITED(${nativeType}, ${parentType})
+
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(${nativeType}, ${parentType})
+ $*{traverse}
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+ NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(${nativeType}, ${parentType})
+ $*{trace}
+ NS_IMPL_CYCLE_COLLECTION_TRACE_END
+
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(${nativeType}, ${parentType})
+ $*{unlink}
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(${nativeType})
+ NS_INTERFACE_MAP_END_INHERITING(${parentType})
+
+ ${nativeType}::${nativeType}(mozilla::dom::EventTarget* aOwner)
+ : ${parentType}(${ctorParams})
+ {
+ }
+
+ ${nativeType}::~${nativeType}()
+ {
+ $*{dropJS}
+ }
+
+ """,
+ ifaceName=self.descriptor.name,
+ nativeType=nativeType,
+ ctorParams=ctorParams,
+ parentType=self.parentType,
+ traverse=self.implTraverse(),
+ unlink=self.implUnlink(),
+ trace=self.implTrace(),
+ dropJS=dropJS)
+ return classImpl + CGBindingImplClass.define(self)
+
+ def getNativeTypeForIDLType(self, type):
+ if type.isPrimitive() and type.tag() in builtinNames:
+ nativeType = CGGeneric(builtinNames[type.tag()])
+ if type.nullable():
+ nativeType = CGTemplatedType("Nullable", nativeType)
+ elif type.isEnum():
+ nativeType = CGGeneric(type.unroll().inner.identifier.name)
+ if type.nullable():
+ nativeType = CGTemplatedType("Nullable", nativeType)
+ elif type.isDOMString() or type.isUSVString():
+ nativeType = CGGeneric("nsString")
+ elif type.isByteString():
+ nativeType = CGGeneric("nsCString")
+ elif type.isGeckoInterface():
+ iface = type.unroll().inner
+ nativeType = self.descriptor.getDescriptor(
+ iface.identifier.name).nativeType
+ # Now trim off unnecessary namespaces
+ nativeType = nativeType.split("::")
+ if nativeType[0] == "mozilla":
+ nativeType.pop(0)
+ if nativeType[0] == "dom":
+ nativeType.pop(0)
+ nativeType = CGWrapper(CGGeneric("::".join(nativeType)), pre="RefPtr<", post=">")
+ elif type.isAny():
+ nativeType = CGGeneric("JS::Heap<JS::Value>")
+ elif type.isObject() or type.isSpiderMonkeyInterface():
+ nativeType = CGGeneric("JS::Heap<JSObject*>")
+ elif type.isUnion():
+ nativeType = CGGeneric(CGUnionStruct.unionTypeDecl(type, True))
+ elif type.isSequence():
+ if type.nullable():
+ innerType = type.inner.inner
+ else:
+ innerType = type.inner
+ if (not innerType.isPrimitive() and not innerType.isEnum() and
+ not innerType.isDOMString() and not innerType.isByteString() and
+ not innerType.isGeckoInterface()):
+ raise TypeError("Don't know how to properly manage GC/CC for "
+ "event member of type %s" %
+ type)
+ nativeType = CGTemplatedType(
+ "nsTArray",
+ self.getNativeTypeForIDLType(innerType))
+ if type.nullable():
+ nativeType = CGTemplatedType("Nullable", nativeType)
+ else:
+ raise TypeError("Don't know how to declare event member of type %s" %
+ type)
+ return nativeType
+
+
+class CGEventRoot(CGThing):
+ def __init__(self, config, interfaceName):
+ descriptor = config.getDescriptor(interfaceName)
+
+ self.root = CGWrapper(CGEventClass(descriptor),
+ pre="\n", post="\n")
+
+ self.root = CGNamespace.build(["mozilla", "dom"], self.root)
+
+ self.root = CGList([CGClassForwardDeclare("JSContext", isStruct=True),
+ self.root])
+
+ parent = descriptor.interface.parent.identifier.name
+
+ # Throw in our #includes
+ self.root = CGHeaders(
+ [descriptor],
+ [],
+ [],
+ [],
+ [
+ config.getDescriptor(parent).headerFile,
+ "mozilla/Attributes.h",
+ "mozilla/ErrorResult.h",
+ "mozilla/dom/%sBinding.h" % interfaceName,
+ 'mozilla/dom/BindingUtils.h',
+ ],
+ [
+ "%s.h" % interfaceName,
+ "js/GCAPI.h",
+ 'mozilla/dom/Nullable.h',
+ ],
+ "", self.root, config)
+
+ # And now some include guards
+ self.root = CGIncludeGuard(interfaceName, self.root)
+
+ self.root = CGWrapper(
+ self.root,
+ pre=(AUTOGENERATED_WITH_SOURCE_WARNING_COMMENT %
+ os.path.basename(descriptor.interface.filename())))
+
+ self.root = CGWrapper(self.root, pre=dedent("""
+ /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+ /* vim:set ts=2 sw=2 sts=2 et cindent: */
+ /* 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/. */
+
+ """))
+
+ def declare(self):
+ return self.root.declare()
+
+ def define(self):
+ return self.root.define()