Update mozjs.

components/script/dom/bindings/codegen/CodegenRust.py

@@ -1884,7 +1884,7 @@ class AttrDefiner(PropertyDefiner):
             array, name,
             '    JSPropertySpec {\n'
             '        name: JSPropertySpec_Name { string_: %s as *const u8 as *const libc::c_char },\n'
-            '        flags: (%s) as u8,\n'
+            '        flags_: (%s) as u8,\n'
             '        u: JSPropertySpec_AccessorsOrValue {\n'
             '            accessors: JSPropertySpec_AccessorsOrValue_Accessors {\n'
             '                getter: JSPropertySpec_Accessor {\n'
@@ -2741,7 +2741,7 @@ ensure_expando_object(*cx, obj.handle().into(), expando.handle_mut());
     # unforgeable holder for those with the right JSClass. Luckily, there
     # aren't too many globals being created.
     if descriptor.isGlobal():
-        copyFunc = "JS_CopyPropertiesFrom"
+        copyFunc = "JS_CopyOwnPropertiesAndPrivateFields"
     else:
         copyFunc = "JS_InitializePropertiesFromCompatibleNativeObject"
     copyCode += """\
@@ -2783,7 +2783,6 @@ rooted!(in(*cx) let obj = NewProxyObject(
     Handle::from_raw(UndefinedHandleValue),
     proto.get(),
     ptr::null(),
-    false,
 ));
 assert!(!obj.is_null());
 SetProxyReservedSlot(
@@ -6059,7 +6058,7 @@ def generate_imports(config, cgthings, descriptors, callbacks=None, dictionaries
         'js::jsapi::JSValueType',
         'js::jsapi::JS_AtomizeAndPinString',
         'js::rust::wrappers::JS_CallFunctionValue',
-        'js::rust::wrappers::JS_CopyPropertiesFrom',
+        'js::rust::wrappers::JS_CopyOwnPropertiesAndPrivateFields',
         'js::rust::wrappers::JS_DefineProperty',
         'js::rust::wrappers::JS_DefinePropertyById2',
         'js::jsapi::JS_ForwardGetPropertyTo',

components/script/dom/bindings/conversions.rs

@@ -56,12 +56,12 @@ use js::glue::{IsWrapper, UnwrapObjectDynamic};
 use js::glue::{RUST_JSID_IS_INT, RUST_JSID_TO_INT};
 use js::glue::{RUST_JSID_IS_STRING, RUST_JSID_TO_STRING};
 use js::jsapi::{Heap, JSContext, JSObject, JSString};
-use js::jsapi::{IsWindowProxy, JS_NewStringCopyN, JS_StringHasLatin1Chars};
+use js::jsapi::{IsWindowProxy, JS_DeprecatedStringHasLatin1Chars, JS_NewStringCopyN};
 use js::jsapi::{
     JS_GetLatin1StringCharsAndLength, JS_GetTwoByteStringCharsAndLength, JS_IsExceptionPending,
 };
 use js::jsval::{ObjectValue, StringValue, UndefinedValue};
-use js::rust::wrappers::{JS_GetProperty, JS_HasProperty, JS_IsArrayObject};
+use js::rust::wrappers::{IsArrayObject, JS_GetProperty, JS_HasProperty};
 use js::rust::{get_object_class, is_dom_class, is_dom_object, maybe_wrap_value, ToString};
 use js::rust::{HandleId, HandleObject, HandleValue, MutableHandleValue};
 use num_traits::Float;
@@ -220,7 +220,7 @@ impl FromJSValConvertible for DOMString {
 /// Convert the given `JSString` to a `DOMString`. Fails if the string does not
 /// contain valid UTF-16.
 pub unsafe fn jsstring_to_str(cx: *mut JSContext, s: *mut JSString) -> DOMString {
-    let latin1 = JS_StringHasLatin1Chars(s);
+    let latin1 = JS_DeprecatedStringHasLatin1Chars(s);
     DOMString::from_string(if latin1 {
         latin1_to_string(cx, s)
     } else {
@@ -271,7 +271,7 @@ impl FromJSValConvertible for USVString {
             debug!("ToString failed");
             return Err(());
         }
-        let latin1 = JS_StringHasLatin1Chars(jsstr);
+        let latin1 = JS_DeprecatedStringHasLatin1Chars(jsstr);
         if latin1 {
             // FIXME(ajeffrey): Convert directly from DOMString to USVString
             return Ok(ConversionResult::Success(USVString(String::from(
@@ -317,7 +317,7 @@ impl FromJSValConvertible for ByteString {
             return Err(());
         }
 
-        let latin1 = JS_StringHasLatin1Chars(string);
+        let latin1 = JS_DeprecatedStringHasLatin1Chars(string);
         if latin1 {
             let mut length = 0;
             let chars = JS_GetLatin1StringCharsAndLength(cx, ptr::null(), string, &mut length);
@@ -564,7 +564,7 @@ impl<T: DomObject> ToJSValConvertible for DomRoot<T> {
 /// NodeList).
 pub unsafe fn is_array_like(cx: *mut JSContext, value: HandleValue) -> bool {
     let mut is_array = false;
-    assert!(JS_IsArrayObject(cx, value, &mut is_array));
+    assert!(IsArrayObject(cx, value, &mut is_array));
     if is_array {
         return true;
     }

components/script/dom/bindings/structuredclone.rs

@@ -116,6 +116,7 @@ unsafe fn write_blob(
 unsafe extern "C" fn read_callback(
     cx: *mut JSContext,
     r: *mut JSStructuredCloneReader,
+    _policy: *const CloneDataPolicy,
     tag: u32,
     _data: u32,
     closure: *mut raw::c_void,
@@ -143,6 +144,7 @@ unsafe extern "C" fn write_callback(
     cx: *mut JSContext,
     w: *mut JSStructuredCloneWriter,
     obj: RawHandleObject,
+    _same_process_scope_required: *mut bool,
     closure: *mut raw::c_void,
 ) -> bool {
     if let Ok(blob) = root_from_object::<Blob>(*obj, cx) {
@@ -216,6 +218,7 @@ unsafe extern "C" fn free_transfer_callback(
 unsafe extern "C" fn can_transfer_callback(
     cx: *mut JSContext,
     obj: RawHandleObject,
+    _same_process_scope_required: *mut bool,
     _closure: *mut raw::c_void,
 ) -> bool {
     if let Ok(_port) = root_from_object::<MessagePort>(*obj, cx) {
@@ -224,7 +227,21 @@ unsafe extern "C" fn can_transfer_callback(
     false
 }
 
-unsafe extern "C" fn report_error_callback(_cx: *mut JSContext, _errorid: u32) {}
+unsafe extern "C" fn report_error_callback(
+    _cx: *mut JSContext,
+    _errorid: u32,
+    _closure: *mut ::std::os::raw::c_void,
+    _error_message: *const ::std::os::raw::c_char,
+) {
+}
+
+unsafe extern "C" fn sab_cloned_callback(
+    _cx: *mut JSContext,
+    _receiving: bool,
+    _closure: *mut ::std::os::raw::c_void,
+) -> bool {
+    false
+}
 
 static STRUCTURED_CLONE_CALLBACKS: JSStructuredCloneCallbacks = JSStructuredCloneCallbacks {
     read: Some(read_callback),
@@ -234,6 +251,7 @@ static STRUCTURED_CLONE_CALLBACKS: JSStructuredCloneCallbacks = JSStructuredClon
     writeTransfer: Some(write_transfer_callback),
     freeTransfer: Some(free_transfer_callback),
     canTransfer: Some(can_transfer_callback),
+    sabCloned: Some(sab_cloned_callback),
 };
 
 /// A data holder for results from, and inputs to, structured-data read/write operations.
@@ -286,15 +304,15 @@ pub fn write(
         );
         let scdata = &mut ((*scbuf).data_);
         let policy = CloneDataPolicy {
-            // TODO: SAB?
-            sharedArrayBuffer_: false,
+            allowIntraClusterClonableSharedObjects_: false,
+            allowSharedMemoryObjects_: false,
         };
         let result = JS_WriteStructuredClone(
             *cx,
             message,
             scdata,
             StructuredCloneScope::DifferentProcess,
-            policy,
+            &policy,
             &STRUCTURED_CLONE_CALLBACKS,
             sc_holder_ptr as *mut raw::c_void,
             val.handle(),
@@ -361,8 +379,9 @@ pub fn read(
             JS_STRUCTURED_CLONE_VERSION,
             StructuredCloneScope::DifferentProcess,
             rval,
-            CloneDataPolicy {
-                sharedArrayBuffer_: false,
+            &CloneDataPolicy {
+                allowIntraClusterClonableSharedObjects_: false,
+                allowSharedMemoryObjects_: false,
             },
             &STRUCTURED_CLONE_CALLBACKS,
             sc_holder_ptr as *mut raw::c_void,

components/script/dom/bindings/utils.rs

@@ -16,7 +16,7 @@ use crate::dom::bindings::str::DOMString;
 use crate::dom::bindings::trace::trace_object;
 use crate::dom::windowproxy;
 use crate::script_runtime::JSContext as SafeJSContext;
-use js::conversions::{jsstr_to_string, ToJSValConvertible};
+use js::conversions::ToJSValConvertible;
 use js::glue::{CallJitGetterOp, CallJitMethodOp, CallJitSetterOp, IsWrapper};
 use js::glue::{GetCrossCompartmentWrapper, JS_GetReservedSlot, WrapperNew};
 use js::glue::{UnwrapObjectDynamic, UnwrapObjectStatic, RUST_JSID_TO_INT, RUST_JSID_TO_STRING};
@@ -27,15 +27,15 @@ use js::jsapi::HandleId as RawHandleId;
 use js::jsapi::HandleObject as RawHandleObject;
 use js::jsapi::MutableHandleIdVector as RawMutableHandleIdVector;
 use js::jsapi::MutableHandleObject as RawMutableHandleObject;
+use js::jsapi::{AtomToLinearString, GetLinearStringCharAt, GetLinearStringLength};
 use js::jsapi::{CallArgs, DOMCallbacks, GetNonCCWObjectGlobal};
 use js::jsapi::{Heap, JSAutoRealm, JSContext, JS_FreezeObject};
+use js::jsapi::{JSAtom, JS_IsExceptionPending, JS_IsGlobalObject};
 use js::jsapi::{JSJitInfo, JSObject, JSTracer, JSWrapObjectCallbacks};
-use js::jsapi::{JS_EnumerateStandardClasses, JS_GetLatin1StringCharsAndLength};
-use js::jsapi::{JS_IsExceptionPending, JS_IsGlobalObject};
 use js::jsapi::{
-    JS_ResolveStandardClass, JS_StringHasLatin1Chars, ObjectOpResult, StringIsArrayIndex1,
-    StringIsArrayIndex2,
+    JS_DeprecatedStringHasLatin1Chars, JS_ResolveStandardClass, ObjectOpResult, StringIsArrayIndex,
 };
+use js::jsapi::{JS_EnumerateStandardClasses, JS_GetLatin1StringCharsAndLength};
 use js::jsval::{JSVal, UndefinedValue};
 use js::rust::wrappers::JS_DeletePropertyById;
 use js::rust::wrappers::JS_ForwardGetPropertyTo;
@@ -191,7 +191,7 @@ pub unsafe fn get_property_on_prototype(
 
 /// Get an array index from the given `jsid`. Returns `None` if the given
 /// `jsid` is not an integer.
-pub unsafe fn get_array_index_from_id(cx: *mut JSContext, id: HandleId) -> Option<u32> {
+pub unsafe fn get_array_index_from_id(_cx: *mut JSContext, id: HandleId) -> Option<u32> {
     let raw_id = id.into();
     if RUST_JSID_IS_INT(raw_id) {
         return Some(RUST_JSID_TO_INT(raw_id) as u32);
@@ -201,7 +201,28 @@ pub unsafe fn get_array_index_from_id(cx: *mut JSContext, id: HandleId) -> Optio
         return None;
     }
 
-    let s = jsstr_to_string(cx, RUST_JSID_TO_STRING(raw_id));
+    let atom = RUST_JSID_TO_STRING(raw_id) as *mut JSAtom;
+    let s = AtomToLinearString(atom);
+    if GetLinearStringLength(s) == 0 {
+        return None;
+    }
+
+    let chars = [GetLinearStringCharAt(s, 0)];
+    let first_char = char::decode_utf16(chars.iter().cloned())
+        .next()
+        .map_or('\0', |r| r.unwrap_or('\0'));
+    if first_char < 'a' || first_char > 'z' {
+        return None;
+    }
+
+    let mut i = 0;
+    if StringIsArrayIndex(s, &mut i) {
+        Some(i)
+    } else {
+        None
+    }
+
+    /*let s = jsstr_to_string(cx, RUST_JSID_TO_STRING(raw_id));
     if s.len() == 0 {
         return None;
     }
@@ -225,7 +246,7 @@ pub unsafe fn get_array_index_from_id(cx: *mut JSContext, id: HandleId) -> Optio
         Some(i)
     } else {
         None
-    }
+    }*/
 }
 
 /// Find the enum equivelent of a string given by `v` in `pairs`.
@@ -436,7 +457,7 @@ pub unsafe extern "C" fn resolve_global(
     }
 
     let string = RUST_JSID_TO_STRING(id);
-    if !JS_StringHasLatin1Chars(string) {
+    if !JS_DeprecatedStringHasLatin1Chars(string) {
         *rval = false;
         return true;
     }

components/script/dom/htmlscriptelement.rs

@@ -66,6 +66,7 @@ use std::io::{Read, Seek, Write};
 use std::mem::replace;
 use std::path::PathBuf;
 use std::process::Command;
+use std::ptr;
 use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 use style::str::{StaticStringVec, HTML_SPACE_CHARACTERS};
@@ -445,6 +446,7 @@ impl FetchResponseListener for ClassicContext {
                 fetch_options: self.fetch_options.clone(),
             });
 
+            let mut token = ptr::null_mut();
             unsafe {
                 assert!(CompileOffThread1(
                     *cx,
@@ -452,6 +454,7 @@ impl FetchResponseListener for ClassicContext {
                     &mut transform_str_to_source_text(&context.script_text) as *mut _,
                     Some(off_thread_compilation_callback),
                     Box::into_raw(context) as *mut c_void,
+                    &mut token,
                 ));
             }
         } else {

components/script/dom/paintworkletglobalscope.rs

@@ -36,7 +36,7 @@ use js::jsapi::JSAutoRealm;
 use js::jsapi::JSObject;
 use js::jsapi::JS_ClearPendingException;
 use js::jsapi::JS_IsExceptionPending;
-use js::jsapi::JS_NewArrayObject;
+use js::jsapi::NewArrayObject;
 use js::jsval::JSVal;
 use js::jsval::ObjectValue;
 use js::jsval::UndefinedValue;
@@ -333,7 +333,7 @@ impl PaintWorkletGlobalScope {
             .collect();
         let arguments_value_array =
             unsafe { HandleValueArray::from_rooted_slice(&*arguments_value_vec) };
-        rooted!(in(*cx) let argument_object = unsafe { JS_NewArrayObject(*cx, &arguments_value_array) });
+        rooted!(in(*cx) let argument_object = unsafe { NewArrayObject(*cx, &arguments_value_array) });
 
         let args_slice = [
             ObjectValue(rendering_context.reflector().get_jsobject().get()),

components/script/dom/webgl2renderingcontext.rs

@@ -112,7 +112,7 @@ fn typedarray_elem_size(typeid: Type) -> usize {
         Type::Int32 | Type::Uint32 | Type::Float32 => 4,
         Type::Int64 | Type::Float64 => 8,
         Type::BigInt64 | Type::BigUint64 => 8,
-        Type::MaxTypedArrayViewType => unreachable!(),
+        Type::Simd128 | Type::MaxTypedArrayViewType => unreachable!(),
     }
 }
 

components/script/dom/webglrenderingcontext.rs

@@ -5042,6 +5042,7 @@ fn array_buffer_type_to_sized_type(type_: Type) -> Option<SizedDataType> {
         Type::BigInt64 |
         Type::BigUint64 |
         Type::MaxTypedArrayViewType |
-        Type::Int64 => None,
+        Type::Int64 |
+        Type::Simd128 => None,
     }
 }