From 552d964ae753d0a90db3180f8ad92eb2537115a9 Mon Sep 17 00:00:00 2001 From: Brian Smith Date: Wed, 27 Sep 2023 18:25:48 -0500 Subject: Issue #1442 - Part 5: Implement WebIDL bindings for Streams. https://bugzilla.mozilla.org/show_bug.cgi?id=1128959 --- dom/bindings/Codegen.py | 32 ++++--- dom/bindings/ReadableStream.h | 28 +++++++ dom/bindings/SpiderMonkeyInterface.h | 144 ++++++++++++++++++++++++++++++++ dom/bindings/TypedArray.h | 134 ++--------------------------- dom/bindings/moz.build | 2 + dom/bindings/parser/WebIDL.py | 39 +++++++-- dom/canvas/CanvasRenderingContext2D.cpp | 8 +- dom/canvas/ImageBitmap.cpp | 2 +- dom/canvas/WebGLTextureUpload.cpp | 4 +- dom/crypto/WebCryptoTask.cpp | 4 +- dom/network/TCPSocketParent.cpp | 2 +- dom/xhr/XMLHttpRequestMainThread.cpp | 2 +- 12 files changed, 244 insertions(+), 157 deletions(-) create mode 100644 dom/bindings/ReadableStream.h create mode 100644 dom/bindings/SpiderMonkeyInterface.h (limited to 'dom') diff --git a/dom/bindings/Codegen.py b/dom/bindings/Codegen.py index a70253fc3a..28f6d2a9a9 100644 --- a/dom/bindings/Codegen.py +++ b/dom/bindings/Codegen.py @@ -1156,7 +1156,10 @@ class CGHeaders(CGWrapper): # 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") + if unrolled.isReadableStream(): + headerSet.add("mozilla/dom/ReadableStream.h") + else: + headerSet.add("mozilla/dom/TypedArray.h") else: try: typeDesc = config.getDescriptor(unrolled.inner.identifier.name) @@ -1371,7 +1374,10 @@ def UnionTypes(unionTypes, config): elif f.isInterface(): if f.isSpiderMonkeyInterface(): headers.add("jsfriendapi.h") - headers.add("mozilla/dom/TypedArray.h") + if f.isReadableStream(): + headers.add("mozilla/dom/ReadableStream.h") + else: + headers.add("mozilla/dom/TypedArray.h") else: try: typeDesc = config.getDescriptor(f.inner.identifier.name) @@ -1457,7 +1463,10 @@ def UnionConversions(unionTypes, config): elif f.isInterface(): if f.isSpiderMonkeyInterface(): headers.add("jsfriendapi.h") - headers.add("mozilla/dom/TypedArray.h") + if f.isReadableStream(): + headers.add("mozilla/dom/ReadableStream.h") + else: + headers.add("mozilla/dom/TypedArray.h") elif f.inner.isExternal(): try: typeDesc = config.getDescriptor(f.inner.identifier.name) @@ -5582,8 +5591,8 @@ def getJSToNativeConversionInfo(type, descriptorProvider, failureCode=None, if type.isSpiderMonkeyInterface(): assert not isEnforceRange and not isClamp name = type.unroll().name # unroll() because it may be nullable - arrayType = CGGeneric(name) - declType = arrayType + interfaceType = CGGeneric(name) + declType = interfaceType if type.nullable(): declType = CGTemplatedType("Nullable", declType) objRef = "${declName}.SetValue()" @@ -5607,10 +5616,11 @@ def getJSToNativeConversionInfo(type, descriptorProvider, failureCode=None, # 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 >. So do a holder if we're - # optional and use a RootedTypedArray otherwise. + # Optional>. So do a + # holder if we're optional and use a RootedSpiderMonkeyInterface + # otherwise. if isOptional: - holderType = CGTemplatedType("TypedArrayRooter", arrayType) + holderType = CGTemplatedType("SpiderMonkeyInterfaceRooter", interfaceType) # 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 @@ -5622,7 +5632,7 @@ def getJSToNativeConversionInfo(type, descriptorProvider, failureCode=None, else: holderType = None holderArgs = None - declType = CGTemplatedType("RootedTypedArray", declType) + declType = CGTemplatedType("RootedSpiderMonkeyInterface", declType) declArgs = "cx" else: holderType = None @@ -6371,7 +6381,7 @@ def getMaybeWrapValueFuncForType(type): if type.nullable(): return "MaybeWrapObjectOrNullValue" return "MaybeWrapObjectValue" - # Spidermonkey interfaces are never DOM objects. Neither are sequences or + # 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(): @@ -13679,7 +13689,7 @@ class ForwardDeclarationBuilder: except NoSuchDescriptorError: pass - # Note: Spidermonkey interfaces are typedefs, so can't be + # Note: SpiderMonkey interfaces are typedefs, so can't be # forward-declared elif t.isPromise(): self.addInMozillaDom("Promise") diff --git a/dom/bindings/ReadableStream.h b/dom/bindings/ReadableStream.h new file mode 100644 index 0000000000..1ea7ac4d88 --- /dev/null +++ b/dom/bindings/ReadableStream.h @@ -0,0 +1,28 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +#ifndef mozilla_dom_ReadableStream_h +#define mozilla_dom_ReadableStream_h + +#include "mozilla/dom/SpiderMonkeyInterface.h" + +namespace mozilla { +namespace dom { + +struct ReadableStream : public SpiderMonkeyInterfaceObjectStorage +{ + inline bool Init(JSObject* obj) + { + MOZ_ASSERT(!inited()); + mImplObj = mWrappedObj = js::UnwrapReadableStream(obj); + return inited(); + } +}; + +} // namespace dom +} // namespace mozilla + +#endif /* mozilla_dom_ReadableStream_h */ diff --git a/dom/bindings/SpiderMonkeyInterface.h b/dom/bindings/SpiderMonkeyInterface.h new file mode 100644 index 0000000000..f852afddaf --- /dev/null +++ b/dom/bindings/SpiderMonkeyInterface.h @@ -0,0 +1,144 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +#ifndef mozilla_dom_SpiderMonkeyInterface_h +#define mozilla_dom_SpiderMonkeyInterface_h + +#include "jsapi.h" +#include "jsfriendapi.h" +#include "js/TracingAPI.h" + +namespace mozilla { +namespace dom { + +/* + * Class that just handles the JSObject storage and tracing for spidermonkey + * interfaces + */ +struct SpiderMonkeyInterfaceObjectStorage +{ +protected: + JSObject* mImplObj; + JSObject* mWrappedObj; + + SpiderMonkeyInterfaceObjectStorage() + : mImplObj(nullptr), + mWrappedObj(nullptr) + { + } + + SpiderMonkeyInterfaceObjectStorage(SpiderMonkeyInterfaceObjectStorage&& aOther) + : mImplObj(aOther.mImplObj), + mWrappedObj(aOther.mWrappedObj) + { + aOther.mImplObj = nullptr; + aOther.mWrappedObj = nullptr; + } + +public: + inline void TraceSelf(JSTracer* trc) + { + JS::UnsafeTraceRoot(trc, &mImplObj, "SpiderMonkeyInterfaceObjectStorage.mImplObj"); + JS::UnsafeTraceRoot(trc, &mWrappedObj, "SpiderMonkeyInterfaceObjectStorage.mWrappedObj"); + } + + inline bool inited() const + { + return !!mImplObj; + } + + inline bool WrapIntoNewCompartment(JSContext* cx) + { + return JS_WrapObject(cx, + JS::MutableHandle::fromMarkedLocation(&mWrappedObj)); + } + + inline JSObject *Obj() const + { + MOZ_ASSERT(inited()); + return mWrappedObj; + } + +private: + SpiderMonkeyInterfaceObjectStorage(const SpiderMonkeyInterfaceObjectStorage&) = delete; +}; + +// A class for rooting an existing SpiderMonkey Interface struct +template +class MOZ_RAII SpiderMonkeyInterfaceRooter : private JS::CustomAutoRooter +{ +public: + template + SpiderMonkeyInterfaceRooter(const CX& cx, + InterfaceType* aInterface MOZ_GUARD_OBJECT_NOTIFIER_PARAM) + : JS::CustomAutoRooter(cx MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT), + mInterface(aInterface) + { + } + + virtual void trace(JSTracer* trc) override + { + mInterface->TraceSelf(trc); + } + +private: + SpiderMonkeyInterfaceObjectStorage* const mInterface; +}; + +// And a specialization for dealing with nullable SpiderMonkey interfaces +template struct Nullable; +template +class MOZ_RAII SpiderMonkeyInterfaceRooter> : + private JS::CustomAutoRooter +{ +public: + template + SpiderMonkeyInterfaceRooter(const CX& cx, + Nullable* aInterface MOZ_GUARD_OBJECT_NOTIFIER_PARAM) + : JS::CustomAutoRooter(cx MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT), + mInterface(aInterface) + { + } + + virtual void trace(JSTracer* trc) override + { + if (!mInterface->IsNull()) { + mInterface->Value().TraceSelf(trc); + } + } + +private: + Nullable* const mInterface; +}; + +// Class for easily setting up a rooted SpiderMonkey interface object on the +// stack +template +class MOZ_RAII RootedSpiderMonkeyInterface final : public InterfaceType, + private SpiderMonkeyInterfaceRooter +{ +public: + template + explicit RootedSpiderMonkeyInterface(const CX& cx MOZ_GUARD_OBJECT_NOTIFIER_PARAM) + : InterfaceType(), + SpiderMonkeyInterfaceRooter(cx, this + MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT) + { + } + + template + RootedSpiderMonkeyInterface(const CX& cx, JSObject* obj MOZ_GUARD_OBJECT_NOTIFIER_PARAM) + : InterfaceType(obj), + SpiderMonkeyInterfaceRooter(cx, this + MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT) + { + } +}; + +} // namespace dom +} // namespace mozilla + +#endif /* mozilla_dom_SpiderMonkeyInterface_h */ diff --git a/dom/bindings/TypedArray.h b/dom/bindings/TypedArray.h index 631707579b..8de0621d46 100644 --- a/dom/bindings/TypedArray.h +++ b/dom/bindings/TypedArray.h @@ -6,51 +6,15 @@ #ifndef mozilla_dom_TypedArray_h #define mozilla_dom_TypedArray_h -#include "jsapi.h" -#include "jsfriendapi.h" -#include "js/RootingAPI.h" -#include "js/TracingAPI.h" #include "mozilla/Attributes.h" #include "mozilla/Move.h" #include "mozilla/dom/BindingDeclarations.h" +#include "mozilla/dom/SpiderMonkeyInterface.h" #include "nsWrapperCache.h" namespace mozilla { namespace dom { -/* - * Class that just handles the JSObject storage and tracing for typed arrays - */ -struct TypedArrayObjectStorage : AllTypedArraysBase { -protected: - JSObject* mTypedObj; - JSObject* mWrappedObj; - - TypedArrayObjectStorage() - : mTypedObj(nullptr), - mWrappedObj(nullptr) - { - } - - TypedArrayObjectStorage(TypedArrayObjectStorage&& aOther) - : mTypedObj(aOther.mTypedObj), - mWrappedObj(aOther.mWrappedObj) - { - aOther.mTypedObj = nullptr; - aOther.mWrappedObj = nullptr; - } - -public: - inline void TraceSelf(JSTracer* trc) - { - JS::UnsafeTraceRoot(trc, &mTypedObj, "TypedArray.mTypedObj"); - JS::UnsafeTraceRoot(trc, &mWrappedObj, "TypedArray.mWrappedObj"); - } - -private: - TypedArrayObjectStorage(const TypedArrayObjectStorage&) = delete; -}; - /* * Various typed array classes for argument conversion. We have a base class * that has a way of initializing a TypedArray from an existing typed array, and @@ -60,7 +24,9 @@ private: template -struct TypedArray_base : public TypedArrayObjectStorage { +struct TypedArray_base : public SpiderMonkeyInterfaceObjectStorage, + AllTypedArraysBase +{ typedef T element_type; TypedArray_base() @@ -72,7 +38,7 @@ struct TypedArray_base : public TypedArrayObjectStorage { } TypedArray_base(TypedArray_base&& aOther) - : TypedArrayObjectStorage(Move(aOther)), + : SpiderMonkeyInterfaceObjectStorage(Move(aOther)), mData(aOther.mData), mLength(aOther.mLength), mShared(aOther.mShared), @@ -94,14 +60,10 @@ public: inline bool Init(JSObject* obj) { MOZ_ASSERT(!inited()); - mTypedObj = mWrappedObj = UnwrapArray(obj); + mImplObj = mWrappedObj = UnwrapArray(obj); return inited(); } - inline bool inited() const { - return !!mTypedObj; - } - // About shared memory: // // Any DOM TypedArray as well as any DOM ArrayBufferView that does @@ -173,22 +135,11 @@ public: return mLength; } - inline JSObject *Obj() const { - MOZ_ASSERT(inited()); - return mWrappedObj; - } - - inline bool WrapIntoNewCompartment(JSContext* cx) - { - return JS_WrapObject(cx, - JS::MutableHandle::fromMarkedLocation(&mWrappedObj)); - } - inline void ComputeLengthAndData() const { MOZ_ASSERT(inited()); MOZ_ASSERT(!mComputed); - GetLengthAndDataAndSharedness(mTypedObj, &mLength, &mShared, &mData); + GetLengthAndDataAndSharedness(mImplObj, &mLength, &mShared, &mData); mComputed = true; } @@ -363,77 +314,6 @@ class TypedArrayCreator const ArrayType& mArray; }; -// A class for rooting an existing TypedArray struct -template -class MOZ_RAII TypedArrayRooter : private JS::CustomAutoRooter -{ -public: - template - TypedArrayRooter(const CX& cx, - ArrayType* aArray MOZ_GUARD_OBJECT_NOTIFIER_PARAM) : - JS::CustomAutoRooter(cx MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT), - mArray(aArray) - { - } - - virtual void trace(JSTracer* trc) override - { - mArray->TraceSelf(trc); - } - -private: - TypedArrayObjectStorage* const mArray; -}; - -// And a specialization for dealing with nullable typed arrays -template struct Nullable; -template -class MOZ_RAII TypedArrayRooter > : - private JS::CustomAutoRooter -{ -public: - template - TypedArrayRooter(const CX& cx, - Nullable* aArray MOZ_GUARD_OBJECT_NOTIFIER_PARAM) : - JS::CustomAutoRooter(cx MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT), - mArray(aArray) - { - } - - virtual void trace(JSTracer* trc) override - { - if (!mArray->IsNull()) { - mArray->Value().TraceSelf(trc); - } - } - -private: - Nullable* const mArray; -}; - -// Class for easily setting up a rooted typed array object on the stack -template -class MOZ_RAII RootedTypedArray final : public ArrayType, - private TypedArrayRooter -{ -public: - template - explicit RootedTypedArray(const CX& cx MOZ_GUARD_OBJECT_NOTIFIER_PARAM) : - ArrayType(), - TypedArrayRooter(cx, this - MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT) - { - } - - template - RootedTypedArray(const CX& cx, JSObject* obj MOZ_GUARD_OBJECT_NOTIFIER_PARAM) : - ArrayType(obj), - TypedArrayRooter(cx, this - MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT) - { - } -}; - } // namespace dom } // namespace mozilla diff --git a/dom/bindings/moz.build b/dom/bindings/moz.build index 9afaf4fd45..60309080e4 100644 --- a/dom/bindings/moz.build +++ b/dom/bindings/moz.build @@ -38,9 +38,11 @@ EXPORTS.mozilla.dom += [ 'NonRefcountedDOMObject.h', 'Nullable.h', 'PrimitiveConversions.h', + 'ReadableStream.h', 'Record.h', 'RootedDictionary.h', 'SimpleGlobalObject.h', + 'SpiderMonkeyInterface.h', 'StructuredClone.h', 'ToJSValue.h', 'TypedArray.h', diff --git a/dom/bindings/parser/WebIDL.py b/dom/bindings/parser/WebIDL.py index 59db43f6bd..0aa3afa4e8 100644 --- a/dom/bindings/parser/WebIDL.py +++ b/dom/bindings/parser/WebIDL.py @@ -2054,6 +2054,9 @@ class IDLType(IDLObject): def isRecord(self): return False + def isReadableStream(self): + return False + def isArrayBuffer(self): return False @@ -2081,12 +2084,12 @@ class IDLType(IDLObject): def isSpiderMonkeyInterface(self): """ Returns a boolean indicating whether this type is an 'interface' - type that is implemented in Spidermonkey. At the moment, this - only returns true for the types from the TypedArray spec. """ + type that is implemented in SpiderMonkey. """ return self.isInterface() and (self.isArrayBuffer() or self.isArrayBufferView() or self.isSharedArrayBuffer() or - self.isTypedArray()) + self.isTypedArray() or + self.isReadableStream()) def isDictionary(self): return False @@ -2275,6 +2278,9 @@ class IDLNullableType(IDLParameterizedType): def isRecord(self): return self.inner.isRecord() + def isReadableStream(self): + return self.inner.isReadableStream() + def isArrayBuffer(self): return self.inner.isArrayBuffer() @@ -2634,6 +2640,9 @@ class IDLTypedefType(IDLType): def isRecord(self): return self.inner.isRecord() + def isReadableStream(self): + return self.inner.isReadableStream() + def isDictionary(self): return self.inner.isDictionary() @@ -2945,7 +2954,8 @@ class IDLBuiltinType(IDLType): 'Int32Array', 'Uint32Array', 'Float32Array', - 'Float64Array' + 'Float64Array', + 'ReadableStream', ) TagLookup = { @@ -2980,7 +2990,8 @@ class IDLBuiltinType(IDLType): Types.Int32Array: IDLType.Tags.interface, Types.Uint32Array: IDLType.Tags.interface, Types.Float32Array: IDLType.Tags.interface, - Types.Float64Array: IDLType.Tags.interface + Types.Float64Array: IDLType.Tags.interface, + Types.ReadableStream: IDLType.Tags.interface, } def __init__(self, location, name, type): @@ -3027,6 +3038,9 @@ class IDLBuiltinType(IDLType): return (self._typeTag >= IDLBuiltinType.Types.Int8Array and self._typeTag <= IDLBuiltinType.Types.Float64Array) + def isReadableStream(self): + return self._typeTag == IDLBuiltinType.Types.ReadableStream + def isInterface(self): # TypedArray things are interface types per the TypedArray spec, # but we handle them as builtins because SpiderMonkey implements @@ -3034,7 +3048,8 @@ class IDLBuiltinType(IDLType): return (self.isArrayBuffer() or self.isArrayBufferView() or self.isSharedArrayBuffer() or - self.isTypedArray()) + self.isTypedArray() or + self.isReadableStream()) def isNonCallbackInterface(self): # All the interfaces we can be are non-callback @@ -3104,6 +3119,7 @@ class IDLBuiltinType(IDLType): # that's not an ArrayBuffer or a callback interface (self.isArrayBuffer() and not other.isArrayBuffer()) or (self.isSharedArrayBuffer() and not other.isSharedArrayBuffer()) or + (self.isReadableStream() and not other.isReadableStream()) or # ArrayBufferView is distinguishable from everything # that's not an ArrayBufferView or typed array. (self.isArrayBufferView() and not other.isArrayBufferView() and @@ -3213,7 +3229,10 @@ BuiltinTypes = { IDLBuiltinType.Types.Float32Array), IDLBuiltinType.Types.Float64Array: IDLBuiltinType(BuiltinLocation(""), "Float64Array", - IDLBuiltinType.Types.Float64Array) + IDLBuiltinType.Types.Float64Array), + IDLBuiltinType.Types.ReadableStream: + IDLBuiltinType(BuiltinLocation(""), "ReadableStream", + IDLBuiltinType.Types.ReadableStream), } @@ -5232,7 +5251,8 @@ class Tokenizer(object): "maplike": "MAPLIKE", "setlike": "SETLIKE", "iterable": "ITERABLE", - "namespace": "NAMESPACE" + "namespace": "NAMESPACE", + "ReadableStream": "READABLESTREAM", } tokens.extend(keywords.values()) @@ -6420,6 +6440,7 @@ class Parser(Tokenizer): NonAnyType : PrimitiveType Null | ARRAYBUFFER Null | SHAREDARRAYBUFFER Null + | READABLESTREAM Null | OBJECT Null """ if p[1] == "object": @@ -6428,6 +6449,8 @@ class Parser(Tokenizer): type = BuiltinTypes[IDLBuiltinType.Types.ArrayBuffer] elif p[1] == "SharedArrayBuffer": type = BuiltinTypes[IDLBuiltinType.Types.SharedArrayBuffer] + elif p[1] == "ReadableStream": + type = BuiltinTypes[IDLBuiltinType.Types.ReadableStream] else: type = BuiltinTypes[p[1]] diff --git a/dom/canvas/CanvasRenderingContext2D.cpp b/dom/canvas/CanvasRenderingContext2D.cpp index ed263f75d2..1e7eab82b2 100644 --- a/dom/canvas/CanvasRenderingContext2D.cpp +++ b/dom/canvas/CanvasRenderingContext2D.cpp @@ -2974,8 +2974,8 @@ ValidateRect(double& aX, double& aY, double& aWidth, double& aHeight, bool aIsZe // The values of canvas API input are in double precision, but Moz2D APIs are // using float precision. Bypass canvas API calls when the input is out of // float precision to avoid precision problem - if (!std::isfinite((float)aX) | !std::isfinite((float)aY) | - !std::isfinite((float)aWidth) | !std::isfinite((float)aHeight)) { + if (!std::isfinite((float)aX) || !std::isfinite((float)aY) || + !std::isfinite((float)aWidth) || !std::isfinite((float)aHeight)) { return false; } @@ -5959,7 +5959,7 @@ void CanvasRenderingContext2D::PutImageData(ImageData& aImageData, double aDx, double aDy, ErrorResult& aError) { - RootedTypedArray arr(RootingCx()); + RootedSpiderMonkeyInterface arr(RootingCx()); DebugOnly inited = arr.Init(aImageData.GetDataObject()); MOZ_ASSERT(inited); @@ -5975,7 +5975,7 @@ CanvasRenderingContext2D::PutImageData(ImageData& aImageData, double aDx, double aDirtyHeight, ErrorResult& aError) { - RootedTypedArray arr(RootingCx()); + RootedSpiderMonkeyInterface arr(RootingCx()); DebugOnly inited = arr.Init(aImageData.GetDataObject()); MOZ_ASSERT(inited); diff --git a/dom/canvas/ImageBitmap.cpp b/dom/canvas/ImageBitmap.cpp index 042c0fa11a..7aaf4e74d8 100644 --- a/dom/canvas/ImageBitmap.cpp +++ b/dom/canvas/ImageBitmap.cpp @@ -929,7 +929,7 @@ ImageBitmap::CreateInternal(nsIGlobalObject* aGlobal, ImageData& aImageData, const Maybe& aCropRect, ErrorResult& aRv) { // Copy data into SourceSurface. - RootedTypedArray array(RootingCx()); + RootedSpiderMonkeyInterface array(RootingCx()); DebugOnly inited = array.Init(aImageData.GetDataObject()); MOZ_ASSERT(inited); diff --git a/dom/canvas/WebGLTextureUpload.cpp b/dom/canvas/WebGLTextureUpload.cpp index ed199cfb43..661fb91ce2 100644 --- a/dom/canvas/WebGLTextureUpload.cpp +++ b/dom/canvas/WebGLTextureUpload.cpp @@ -475,7 +475,7 @@ WebGLTexture::TexImage(const char* funcName, TexImageTarget target, GLint level, GLsizei depth, GLint border, const webgl::PackingInfo& pi, const TexImageSource& src) { - dom::RootedTypedArray scopedArr(dom::RootingCx()); + dom::RootedSpiderMonkeyInterface scopedArr(dom::RootingCx()); const auto blob = ValidateTexOrSubImage(mContext, funcName, target, width, height, depth, border, pi, src, &scopedArr); if (!blob) @@ -491,7 +491,7 @@ WebGLTexture::TexSubImage(const char* funcName, TexImageTarget target, GLint lev const webgl::PackingInfo& pi, const TexImageSource& src) { const GLint border = 0; - dom::RootedTypedArray scopedArr(dom::RootingCx()); + dom::RootedSpiderMonkeyInterface scopedArr(dom::RootingCx()); const auto blob = ValidateTexOrSubImage(mContext, funcName, target, width, height, depth, border, pi, src, &scopedArr); if (!blob) diff --git a/dom/crypto/WebCryptoTask.cpp b/dom/crypto/WebCryptoTask.cpp index ed47325f8d..34a4c877d7 100644 --- a/dom/crypto/WebCryptoTask.cpp +++ b/dom/crypto/WebCryptoTask.cpp @@ -1366,7 +1366,7 @@ public: mDataIsJwk = false; // Try ArrayBuffer - RootedTypedArray ab(aCx); + RootedSpiderMonkeyInterface ab(aCx); if (ab.Init(aKeyData)) { if (!mKeyData.Assign(ab)) { mEarlyRv = NS_ERROR_DOM_OPERATION_ERR; @@ -1375,7 +1375,7 @@ public: } // Try ArrayBufferView - RootedTypedArray abv(aCx); + RootedSpiderMonkeyInterface abv(aCx); if (abv.Init(aKeyData)) { if (!mKeyData.Assign(abv)) { mEarlyRv = NS_ERROR_DOM_OPERATION_ERR; diff --git a/dom/network/TCPSocketParent.cpp b/dom/network/TCPSocketParent.cpp index 96eab44510..0e7f0e17ae 100644 --- a/dom/network/TCPSocketParent.cpp +++ b/dom/network/TCPSocketParent.cpp @@ -310,7 +310,7 @@ TCPSocketParent::RecvData(const SendableData& aData, const nsTArray& buffer = aData.get_ArrayOfuint8_t(); bool ok = IPC::DeserializeArrayBuffer(autoCx, buffer, &val); NS_ENSURE_TRUE(ok, true); - RootedTypedArray data(autoCx); + RootedSpiderMonkeyInterface data(autoCx); data.Init(&val.toObject()); Optional byteLength(buffer.Length()); mSocket->SendWithTrackingNumber(autoCx, data, 0, byteLength, aTrackingNumber, rv); diff --git a/dom/xhr/XMLHttpRequestMainThread.cpp b/dom/xhr/XMLHttpRequestMainThread.cpp index d97476ef61..02d148e16d 100644 --- a/dom/xhr/XMLHttpRequestMainThread.cpp +++ b/dom/xhr/XMLHttpRequestMainThread.cpp @@ -2826,7 +2826,7 @@ XMLHttpRequestMainThread::Send(nsIVariant* aVariant) nsresult rv = aVariant->GetAsJSVal(&realVal); if (NS_SUCCEEDED(rv) && !realVal.isPrimitive()) { JS::Rooted obj(rootingCx, realVal.toObjectOrNull()); - RootedTypedArray buf(rootingCx); + RootedSpiderMonkeyInterface buf(rootingCx); if (buf.Init(obj)) { RequestBody body(&buf); return SendInternal(&body); -- cgit v1.2.3