Add InRealm argument to Callback trait

components/script/dom/promise.rs

@@ -17,7 +17,7 @@ use crate::dom::bindings::reflector::{DomObject, MutDomObject, Reflector};
 use crate::dom::bindings::utils::AsCCharPtrPtr;
 use crate::dom::globalscope::GlobalScope;
 use crate::dom::promisenativehandler::PromiseNativeHandler;
-use crate::realms::{enter_realm, InRealm};
+use crate::realms::{enter_realm, AlreadyInRealm, InRealm};
 use crate::script_runtime::JSContext as SafeJSContext;
 use crate::script_thread::ScriptThread;
 use dom_struct::dom_struct;
@@ -292,21 +292,28 @@ unsafe extern "C" fn native_handler_callback(
     argc: u32,
     vp: *mut JSVal,
 ) -> bool {
+    let cx = SafeJSContext::from_ptr(cx);
+    let in_realm_proof = AlreadyInRealm::assert_for_cx(cx);
+
     let args = CallArgs::from_vp(vp, argc);
-    rooted!(in(cx) let v = *GetFunctionNativeReserved(args.callee(), SLOT_NATIVEHANDLER));
+    rooted!(in(*cx) let v = *GetFunctionNativeReserved(args.callee(), SLOT_NATIVEHANDLER));
     assert!(v.get().is_object());
 
-    let handler = root_from_object::<PromiseNativeHandler>(v.to_object(), cx)
+    let handler = root_from_object::<PromiseNativeHandler>(v.to_object(), *cx)
         .expect("unexpected value for native handler in promise native handler callback");
 
-    rooted!(in(cx) let v = *GetFunctionNativeReserved(args.callee(), SLOT_NATIVEHANDLER_TASK));
+    rooted!(in(*cx) let v = *GetFunctionNativeReserved(args.callee(), SLOT_NATIVEHANDLER_TASK));
     match v.to_int32() {
-        v if v == NativeHandlerTask::Resolve as i32 => {
+        v if v == NativeHandlerTask::Resolve as i32 => handler.resolved_callback(
-            handler.resolved_callback(cx, HandleValue::from_raw(args.get(0)))
+            *cx,
-        },
+            HandleValue::from_raw(args.get(0)),
-        v if v == NativeHandlerTask::Reject as i32 => {
+            InRealm::Already(&in_realm_proof),
-            handler.rejected_callback(cx, HandleValue::from_raw(args.get(0)))
+        ),
-        },
+        v if v == NativeHandlerTask::Reject as i32 => handler.rejected_callback(
+            *cx,
+            HandleValue::from_raw(args.get(0)),
+            InRealm::Already(&in_realm_proof),
+        ),
         _ => panic!("unexpected native handler task value"),
     };
 

components/script/dom/promisenativehandler.rs

@@ -6,13 +6,14 @@ use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
 use crate::dom::bindings::root::DomRoot;
 use crate::dom::bindings::trace::JSTraceable;
 use crate::dom::globalscope::GlobalScope;
+use crate::realms::InRealm;
 use dom_struct::dom_struct;
 use js::jsapi::JSContext;
 use js::rust::HandleValue;
 use malloc_size_of::MallocSizeOf;
 
 pub trait Callback: JSTraceable + MallocSizeOf {
-    fn callback(&self, cx: *mut JSContext, v: HandleValue);
+    fn callback(&self, cx: *mut JSContext, v: HandleValue, realm: InRealm);
 }
 
 #[dom_struct]
@@ -38,17 +39,22 @@ impl PromiseNativeHandler {
         )
     }
 
-    fn callback(callback: &Option<Box<dyn Callback>>, cx: *mut JSContext, v: HandleValue) {
+    fn callback(
+        callback: &Option<Box<dyn Callback>>,
+        cx: *mut JSContext,
+        v: HandleValue,
+        realm: InRealm,
+    ) {
         if let Some(ref callback) = *callback {
-            callback.callback(cx, v)
+            callback.callback(cx, v, realm)
         }
     }
 
-    pub fn resolved_callback(&self, cx: *mut JSContext, v: HandleValue) {
+    pub fn resolved_callback(&self, cx: *mut JSContext, v: HandleValue, realm: InRealm) {
-        PromiseNativeHandler::callback(&self.resolve, cx, v)
+        PromiseNativeHandler::callback(&self.resolve, cx, v, realm)
     }
 
-    pub fn rejected_callback(&self, cx: *mut JSContext, v: HandleValue) {
+    pub fn rejected_callback(&self, cx: *mut JSContext, v: HandleValue, realm: InRealm) {
-        PromiseNativeHandler::callback(&self.reject, cx, v)
+        PromiseNativeHandler::callback(&self.reject, cx, v, realm)
     }
 }

components/script/dom/testbinding.rs

@@ -48,7 +48,7 @@ use crate::dom::globalscope::GlobalScope;
 use crate::dom::promise::Promise;
 use crate::dom::promisenativehandler::{Callback, PromiseNativeHandler};
 use crate::dom::url::URL;
-use crate::realms::{AlreadyInRealm, InRealm};
+use crate::realms::InRealm;
 use crate::script_runtime::JSContext as SafeJSContext;
 use crate::timers::OneshotTimerCallback;
 use dom_struct::dom_struct;
@@ -1010,11 +1010,8 @@ impl TestBindingMethods for TestBinding {
         }
         impl Callback for SimpleHandler {
             #[allow(unsafe_code)]
-            fn callback(&self, cx: *mut JSContext, v: HandleValue) {
+            fn callback(&self, cx: *mut JSContext, v: HandleValue, realm: InRealm) {
-                let global = unsafe {
+                let global = unsafe { GlobalScope::from_context(cx, realm) };
-                    let in_realm_proof = AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx));
-                    GlobalScope::from_context(cx, InRealm::Already(&in_realm_proof))
-                };
                 let _ = self.handler.Call_(&*global, v, ExceptionHandling::Report);
             }
         }

components/script/script_module.rs

@@ -674,7 +674,7 @@ impl ModuleHandler {
 }
 
 impl Callback for ModuleHandler {
-    fn callback(&self, _cx: *mut JSContext, _v: HandleValue) {
+    fn callback(&self, _cx: *mut JSContext, _v: HandleValue, _realm: InRealm) {
         let task = self.task.borrow_mut().take().unwrap();
         task.run_box();
     }