tauri-apps/archived-cef-rs
1
0
Fork 0
mirror of https://github.com/tauri-apps/cef-rs.git synced 2026-01-31 00:55:21 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #26 from wravery/fix-224

Browse Source 
Fix 224
This commit is contained in:
Bill Avery
2025-10-03 11:28:56 -07:00
committed by GitHub
parent 84a7f59d85 3e53341d98
commit e90fb14bb7
5 changed files with 388 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
cef/src/bindings/aarch64_apple_darwin.rs
View File

@@ -20727,28 +20727,30 @@ mod impl_cef_life_span_handler_t {
Some(WrapParamRef::<WindowInfo, _>::from(arg_window_info))
};
let arg_window_info = arg_window_info.as_mut().map(|arg| arg.as_mut());
let mut arg_client = unsafe { arg_client.as_mut() }.and_then(|ptr| {
let out_client = arg_client;
let mut wrap_client = unsafe { arg_client.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(Client(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_client = Some(&mut arg_client);
let arg_client = Some(&mut wrap_client);
let mut arg_settings = if arg_settings.is_null() {
None
} else {
Some(WrapParamRef::<BrowserSettings, _>::from(arg_settings))
};
let arg_settings = arg_settings.as_mut().map(|arg| arg.as_mut());
let mut arg_extra_info = unsafe { arg_extra_info.as_mut() }.and_then(|ptr| {
let out_extra_info = arg_extra_info;
let mut wrap_extra_info = unsafe { arg_extra_info.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(DictionaryValue(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_extra_info = Some(&mut arg_extra_info);
let arg_extra_info = Some(&mut wrap_extra_info);
let mut arg_no_javascript_access = if arg_no_javascript_access.is_null() {
None
} else {
@@ -20757,7 +20759,7 @@ mod impl_cef_life_span_handler_t {
))
};
let arg_no_javascript_access = arg_no_javascript_access.as_mut().map(|arg| arg.as_mut());
ImplLifeSpanHandler::on_before_popup(
let result = ImplLifeSpanHandler::on_before_popup(
&arg_self_.interface,
arg_browser,
arg_frame,
@@ -20772,7 +20774,17 @@ mod impl_cef_life_span_handler_t {
arg_settings,
arg_extra_info,
arg_no_javascript_access,
)
);
if let (Some(out_client), Some(wrap_client)) = (unsafe { out_client.as_mut() }, wrap_client)
{
*out_client = wrap_client.wrap_result();
}
if let (Some(out_extra_info), Some(wrap_extra_info)) =
(unsafe { out_extra_info.as_mut() }, wrap_extra_info)
{
*out_extra_info = wrap_extra_info.wrap_result();
}
result
}
extern "C" fn on_before_popup_aborted<I: ImplLifeSpanHandler>(
self_: *mut _cef_life_span_handler_t,
@@ -20827,28 +20839,30 @@ mod impl_cef_life_span_handler_t {
Some(WrapParamRef::<WindowInfo, _>::from(arg_window_info))
};
let arg_window_info = arg_window_info.as_mut().map(|arg| arg.as_mut());
let mut arg_client = unsafe { arg_client.as_mut() }.and_then(|ptr| {
let out_client = arg_client;
let mut wrap_client = unsafe { arg_client.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(Client(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_client = Some(&mut arg_client);
let arg_client = Some(&mut wrap_client);
let mut arg_settings = if arg_settings.is_null() {
None
} else {
Some(WrapParamRef::<BrowserSettings, _>::from(arg_settings))
};
let arg_settings = arg_settings.as_mut().map(|arg| arg.as_mut());
let mut arg_extra_info = unsafe { arg_extra_info.as_mut() }.and_then(|ptr| {
let out_extra_info = arg_extra_info;
let mut wrap_extra_info = unsafe { arg_extra_info.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(DictionaryValue(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_extra_info = Some(&mut arg_extra_info);
let arg_extra_info = Some(&mut wrap_extra_info);
let mut arg_use_default_window = if arg_use_default_window.is_null() {
None
} else {
@@ -20857,7 +20871,7 @@ mod impl_cef_life_span_handler_t {
))
};
let arg_use_default_window = arg_use_default_window.as_mut().map(|arg| arg.as_mut());
ImplLifeSpanHandler::on_before_dev_tools_popup(
let result = ImplLifeSpanHandler::on_before_dev_tools_popup(
&arg_self_.interface,
arg_browser,
arg_window_info,
@@ -20865,7 +20879,16 @@ mod impl_cef_life_span_handler_t {
arg_settings,
arg_extra_info,
arg_use_default_window,
)
);
if let (Some(out_client), Some(wrap_client)) = (unsafe { out_client.as_mut() }, wrap_client)
{
*out_client = wrap_client.wrap_result();
}
if let (Some(out_extra_info), Some(wrap_extra_info)) =
(unsafe { out_extra_info.as_mut() }, wrap_extra_info)
{
*out_extra_info = wrap_extra_info.wrap_result();
}
}
extern "C" fn on_after_created<I: ImplLifeSpanHandler>(
self_: *mut _cef_life_span_handler_t,
@@ -30082,28 +30105,34 @@ mod impl_cef_v8_handler_t {
.collect::<Vec<_>>()
});
let arg_arguments = vec_arguments.as_deref();
let mut arg_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
let out_retval = arg_retval;
let mut wrap_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(V8Value(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_retval = Some(&mut arg_retval);
let arg_retval = Some(&mut wrap_retval);
let mut arg_exception = if arg_exception.is_null() {
None
} else {
Some(arg_exception.into())
};
let arg_exception = arg_exception.as_mut();
ImplV8Handler::execute(
let result = ImplV8Handler::execute(
&arg_self_.interface,
arg_name,
arg_object,
arg_arguments,
arg_retval,
arg_exception,
)
);
if let (Some(out_retval), Some(wrap_retval)) = (unsafe { out_retval.as_mut() }, wrap_retval)
{
*out_retval = wrap_retval.wrap_result();
}
result
}
}
impl ImplV8Handler for V8Handler {
@@ -30303,27 +30332,33 @@ mod impl_cef_v8_accessor_t {
let mut arg_object =
unsafe { arg_object.as_mut() }.map(|arg| V8Value(unsafe { RefGuard::from_raw(arg) }));
let arg_object = arg_object.as_mut();
let mut arg_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
let out_retval = arg_retval;
let mut wrap_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(V8Value(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_retval = Some(&mut arg_retval);
let arg_retval = Some(&mut wrap_retval);
let mut arg_exception = if arg_exception.is_null() {
None
} else {
Some(arg_exception.into())
};
let arg_exception = arg_exception.as_mut();
ImplV8Accessor::get(
let result = ImplV8Accessor::get(
&arg_self_.interface,
arg_name,
arg_object,
arg_retval,
arg_exception,
)
);
if let (Some(out_retval), Some(wrap_retval)) = (unsafe { out_retval.as_mut() }, wrap_retval)
{
*out_retval = wrap_retval.wrap_result();
}
result
}
extern "C" fn set<I: ImplV8Accessor>(
self_: *mut _cef_v8_accessor_t,
@@ -30586,27 +30621,33 @@ mod impl_cef_v8_interceptor_t {
let mut arg_object =
unsafe { arg_object.as_mut() }.map(|arg| V8Value(unsafe { RefGuard::from_raw(arg) }));
let arg_object = arg_object.as_mut();
let mut arg_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
let out_retval = arg_retval;
let mut wrap_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(V8Value(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_retval = Some(&mut arg_retval);
let arg_retval = Some(&mut wrap_retval);
let mut arg_exception = if arg_exception.is_null() {
None
} else {
Some(arg_exception.into())
};
let arg_exception = arg_exception.as_mut();
ImplV8Interceptor::byname(
let result = ImplV8Interceptor::byname(
&arg_self_.interface,
arg_name,
arg_object,
arg_retval,
arg_exception,
)
);
if let (Some(out_retval), Some(wrap_retval)) = (unsafe { out_retval.as_mut() }, wrap_retval)
{
*out_retval = wrap_retval.wrap_result();
}
result
}
extern "C" fn get_byindex<I: ImplV8Interceptor>(
self_: *mut _cef_v8_interceptor_t,
@@ -30622,27 +30663,33 @@ mod impl_cef_v8_interceptor_t {
let mut arg_object =
unsafe { arg_object.as_mut() }.map(|arg| V8Value(unsafe { RefGuard::from_raw(arg) }));
let arg_object = arg_object.as_mut();
let mut arg_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
let out_retval = arg_retval;
let mut wrap_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(V8Value(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_retval = Some(&mut arg_retval);
let arg_retval = Some(&mut wrap_retval);
let mut arg_exception = if arg_exception.is_null() {
None
} else {
Some(arg_exception.into())
};
let arg_exception = arg_exception.as_mut();
ImplV8Interceptor::byindex(
let result = ImplV8Interceptor::byindex(
&arg_self_.interface,
arg_index,
arg_object,
arg_retval,
arg_exception,
)
);
if let (Some(out_retval), Some(wrap_retval)) = (unsafe { out_retval.as_mut() }, wrap_retval)
{
*out_retval = wrap_retval.wrap_result();
}
result
}
extern "C" fn set_byname<I: ImplV8Interceptor>(
self_: *mut _cef_v8_interceptor_t,

138
cef/src/bindings/mod.rs
View File

@@ -37,3 +37,141 @@ pub use x86_64_apple_darwin::*;
mod aarch64_apple_darwin;
#[cfg(all(target_os = "macos", target_arch = "aarch64"))]
pub use aarch64_apple_darwin::*;
#[cfg(test)]
mod test {
use super::*;
use crate::{rc::*, sys};
use std::{cell::RefCell, ptr};
#[derive(Default)]
struct CallInfo {
extra_info: RefCell<Option<DictionaryValue>>,
}
struct TestLifeSpanHandler {
object: *mut RcImpl<sys::_cef_life_span_handler_t, Self>,
call_info: std::rc::Rc<CallInfo>,
}
impl ImplLifeSpanHandler for TestLifeSpanHandler {
fn get_raw(&self) -> *mut sys::_cef_life_span_handler_t {
self.object.cast()
}
fn on_before_popup(
&self,
_browser: Option<&mut Browser>,
_frame: Option<&mut Frame>,
_popup_id: ::std::os::raw::c_int,
_target_url: Option<&CefString>,
_target_frame_name: Option<&CefString>,
_target_disposition: WindowOpenDisposition,
_user_gesture: ::std::os::raw::c_int,
_popup_features: Option<&PopupFeatures>,
_window_info: Option<&mut WindowInfo>,
_client: Option<&mut Option<Client>>,
_settings: Option<&mut BrowserSettings>,
extra_info: Option<&mut Option<DictionaryValue>>,
_no_javascript_access: Option<&mut ::std::os::raw::c_int>,
) -> ::std::os::raw::c_int {
let extra_info = extra_info.expect("extra_info is required");
*extra_info = self.call_info.extra_info.take();
1
}
}
impl WrapLifeSpanHandler for TestLifeSpanHandler {
fn wrap_rc(&mut self, object: *mut RcImpl<sys::_cef_life_span_handler_t, Self>) {
self.object = object;
}
}
impl TestLifeSpanHandler {
fn new(call_info: std::rc::Rc<CallInfo>) -> LifeSpanHandler {
LifeSpanHandler::new(Self {
object: std::ptr::null_mut(),
call_info,
})
}
}
impl Clone for TestLifeSpanHandler {
fn clone(&self) -> Self {
let object = unsafe {
let rc_impl = &mut *self.object;
rc_impl.interface.add_ref();
self.object
};
Self {
object,
call_info: self.call_info.clone(),
}
}
}
impl Rc for TestLifeSpanHandler {
fn as_base(&self) -> &sys::cef_base_ref_counted_t {
unsafe {
let base = &*self.object;
std::mem::transmute(&base.cef_object)
}
}
}
#[test]
fn dictionary_value_out_param() {
#[cfg(target_os = "macos")]
unsafe {
use std::{ffi::CString, os::unix::ffi::OsStrExt};
let cef_dir = sys::get_cef_dir().expect("CEF not found");
let framework_dir = cef_dir
.join(sys::FRAMEWORK_PATH)
.canonicalize()
.expect("failed to get framework path");
let framework_dir =
CString::new(framework_dir.as_os_str().as_bytes()).expect("invalid path");
assert_eq!(sys::cef_load_library(framework_dir.as_ptr().cast()), 1);
}
assert_eq!(initialize(None, None, None, ptr::null_mut()), 0);
let _ = api_hash(sys::CEF_API_VERSION_LAST, 0);
let call_info = std::rc::Rc::new(CallInfo::default());
let extra_info = dictionary_value_create().expect("failed to create dictionary");
let test_key = CefString::from("testKey");
let test_value = CefString::from("testValue");
extra_info.set_string(Some(&test_key), Some(&test_value));
*call_info.extra_info.borrow_mut() = Some(extra_info);
let mut extra_info = None;
let handler = TestLifeSpanHandler::new(call_info);
assert_eq!(
1,
handler.on_before_popup(
None,
None,
1,
None,
None,
sys::cef_window_open_disposition_t::CEF_WOD_CURRENT_TAB.into(),
0,
None,
None,
None,
None,
Some(&mut extra_info),
None,
)
);
let extra_info = extra_info.as_ref().unwrap();
assert_eq!(
"testValue",
CefString::from(&extra_info.string(Some(&test_key))).to_string()
);
}
}

103
cef/src/bindings/x86_64_pc_windows_msvc.rs
View File

@@ -20755,28 +20755,30 @@ mod impl_cef_life_span_handler_t {
Some(WrapParamRef::<WindowInfo, _>::from(arg_window_info))
};
let arg_window_info = arg_window_info.as_mut().map(|arg| arg.as_mut());
let mut arg_client = unsafe { arg_client.as_mut() }.and_then(|ptr| {
let out_client = arg_client;
let mut wrap_client = unsafe { arg_client.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(Client(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_client = Some(&mut arg_client);
let arg_client = Some(&mut wrap_client);
let mut arg_settings = if arg_settings.is_null() {
None
} else {
Some(WrapParamRef::<BrowserSettings, _>::from(arg_settings))
};
let arg_settings = arg_settings.as_mut().map(|arg| arg.as_mut());
let mut arg_extra_info = unsafe { arg_extra_info.as_mut() }.and_then(|ptr| {
let out_extra_info = arg_extra_info;
let mut wrap_extra_info = unsafe { arg_extra_info.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(DictionaryValue(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_extra_info = Some(&mut arg_extra_info);
let arg_extra_info = Some(&mut wrap_extra_info);
let mut arg_no_javascript_access = if arg_no_javascript_access.is_null() {
None
} else {
@@ -20785,7 +20787,7 @@ mod impl_cef_life_span_handler_t {
))
};
let arg_no_javascript_access = arg_no_javascript_access.as_mut().map(|arg| arg.as_mut());
ImplLifeSpanHandler::on_before_popup(
let result = ImplLifeSpanHandler::on_before_popup(
&arg_self_.interface,
arg_browser,
arg_frame,
@@ -20800,7 +20802,17 @@ mod impl_cef_life_span_handler_t {
arg_settings,
arg_extra_info,
arg_no_javascript_access,
)
);
if let (Some(out_client), Some(wrap_client)) = (unsafe { out_client.as_mut() }, wrap_client)
{
*out_client = wrap_client.wrap_result();
}
if let (Some(out_extra_info), Some(wrap_extra_info)) =
(unsafe { out_extra_info.as_mut() }, wrap_extra_info)
{
*out_extra_info = wrap_extra_info.wrap_result();
}
result
}
extern "C" fn on_before_popup_aborted<I: ImplLifeSpanHandler>(
self_: *mut _cef_life_span_handler_t,
@@ -20855,28 +20867,30 @@ mod impl_cef_life_span_handler_t {
Some(WrapParamRef::<WindowInfo, _>::from(arg_window_info))
};
let arg_window_info = arg_window_info.as_mut().map(|arg| arg.as_mut());
let mut arg_client = unsafe { arg_client.as_mut() }.and_then(|ptr| {
let out_client = arg_client;
let mut wrap_client = unsafe { arg_client.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(Client(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_client = Some(&mut arg_client);
let arg_client = Some(&mut wrap_client);
let mut arg_settings = if arg_settings.is_null() {
None
} else {
Some(WrapParamRef::<BrowserSettings, _>::from(arg_settings))
};
let arg_settings = arg_settings.as_mut().map(|arg| arg.as_mut());
let mut arg_extra_info = unsafe { arg_extra_info.as_mut() }.and_then(|ptr| {
let out_extra_info = arg_extra_info;
let mut wrap_extra_info = unsafe { arg_extra_info.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(DictionaryValue(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_extra_info = Some(&mut arg_extra_info);
let arg_extra_info = Some(&mut wrap_extra_info);
let mut arg_use_default_window = if arg_use_default_window.is_null() {
None
} else {
@@ -20885,7 +20899,7 @@ mod impl_cef_life_span_handler_t {
))
};
let arg_use_default_window = arg_use_default_window.as_mut().map(|arg| arg.as_mut());
ImplLifeSpanHandler::on_before_dev_tools_popup(
let result = ImplLifeSpanHandler::on_before_dev_tools_popup(
&arg_self_.interface,
arg_browser,
arg_window_info,
@@ -20893,7 +20907,16 @@ mod impl_cef_life_span_handler_t {
arg_settings,
arg_extra_info,
arg_use_default_window,
)
);
if let (Some(out_client), Some(wrap_client)) = (unsafe { out_client.as_mut() }, wrap_client)
{
*out_client = wrap_client.wrap_result();
}
if let (Some(out_extra_info), Some(wrap_extra_info)) =
(unsafe { out_extra_info.as_mut() }, wrap_extra_info)
{
*out_extra_info = wrap_extra_info.wrap_result();
}
}
extern "C" fn on_after_created<I: ImplLifeSpanHandler>(
self_: *mut _cef_life_span_handler_t,
@@ -30110,28 +30133,34 @@ mod impl_cef_v8_handler_t {
.collect::<Vec<_>>()
});
let arg_arguments = vec_arguments.as_deref();
let mut arg_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
let out_retval = arg_retval;
let mut wrap_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(V8Value(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_retval = Some(&mut arg_retval);
let arg_retval = Some(&mut wrap_retval);
let mut arg_exception = if arg_exception.is_null() {
None
} else {
Some(arg_exception.into())
};
let arg_exception = arg_exception.as_mut();
ImplV8Handler::execute(
let result = ImplV8Handler::execute(
&arg_self_.interface,
arg_name,
arg_object,
arg_arguments,
arg_retval,
arg_exception,
)
);
if let (Some(out_retval), Some(wrap_retval)) = (unsafe { out_retval.as_mut() }, wrap_retval)
{
*out_retval = wrap_retval.wrap_result();
}
result
}
}
impl ImplV8Handler for V8Handler {
@@ -30331,27 +30360,33 @@ mod impl_cef_v8_accessor_t {
let mut arg_object =
unsafe { arg_object.as_mut() }.map(|arg| V8Value(unsafe { RefGuard::from_raw(arg) }));
let arg_object = arg_object.as_mut();
let mut arg_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
let out_retval = arg_retval;
let mut wrap_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(V8Value(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_retval = Some(&mut arg_retval);
let arg_retval = Some(&mut wrap_retval);
let mut arg_exception = if arg_exception.is_null() {
None
} else {
Some(arg_exception.into())
};
let arg_exception = arg_exception.as_mut();
ImplV8Accessor::get(
let result = ImplV8Accessor::get(
&arg_self_.interface,
arg_name,
arg_object,
arg_retval,
arg_exception,
)
);
if let (Some(out_retval), Some(wrap_retval)) = (unsafe { out_retval.as_mut() }, wrap_retval)
{
*out_retval = wrap_retval.wrap_result();
}
result
}
extern "C" fn set<I: ImplV8Accessor>(
self_: *mut _cef_v8_accessor_t,
@@ -30614,27 +30649,33 @@ mod impl_cef_v8_interceptor_t {
let mut arg_object =
unsafe { arg_object.as_mut() }.map(|arg| V8Value(unsafe { RefGuard::from_raw(arg) }));
let arg_object = arg_object.as_mut();
let mut arg_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
let out_retval = arg_retval;
let mut wrap_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(V8Value(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_retval = Some(&mut arg_retval);
let arg_retval = Some(&mut wrap_retval);
let mut arg_exception = if arg_exception.is_null() {
None
} else {
Some(arg_exception.into())
};
let arg_exception = arg_exception.as_mut();
ImplV8Interceptor::byname(
let result = ImplV8Interceptor::byname(
&arg_self_.interface,
arg_name,
arg_object,
arg_retval,
arg_exception,
)
);
if let (Some(out_retval), Some(wrap_retval)) = (unsafe { out_retval.as_mut() }, wrap_retval)
{
*out_retval = wrap_retval.wrap_result();
}
result
}
extern "C" fn get_byindex<I: ImplV8Interceptor>(
self_: *mut _cef_v8_interceptor_t,
@@ -30650,27 +30691,33 @@ mod impl_cef_v8_interceptor_t {
let mut arg_object =
unsafe { arg_object.as_mut() }.map(|arg| V8Value(unsafe { RefGuard::from_raw(arg) }));
let arg_object = arg_object.as_mut();
let mut arg_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
let out_retval = arg_retval;
let mut wrap_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(V8Value(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_retval = Some(&mut arg_retval);
let arg_retval = Some(&mut wrap_retval);
let mut arg_exception = if arg_exception.is_null() {
None
} else {
Some(arg_exception.into())
};
let arg_exception = arg_exception.as_mut();
ImplV8Interceptor::byindex(
let result = ImplV8Interceptor::byindex(
&arg_self_.interface,
arg_index,
arg_object,
arg_retval,
arg_exception,
)
);
if let (Some(out_retval), Some(wrap_retval)) = (unsafe { out_retval.as_mut() }, wrap_retval)
{
*out_retval = wrap_retval.wrap_result();
}
result
}
extern "C" fn set_byname<I: ImplV8Interceptor>(
self_: *mut _cef_v8_interceptor_t,

103
cef/src/bindings/x86_64_unknown_linux_gnu.rs
View File

@@ -20793,28 +20793,30 @@ mod impl_cef_life_span_handler_t {
Some(WrapParamRef::<WindowInfo, _>::from(arg_window_info))
};
let arg_window_info = arg_window_info.as_mut().map(|arg| arg.as_mut());
let mut arg_client = unsafe { arg_client.as_mut() }.and_then(|ptr| {
let out_client = arg_client;
let mut wrap_client = unsafe { arg_client.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(Client(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_client = Some(&mut arg_client);
let arg_client = Some(&mut wrap_client);
let mut arg_settings = if arg_settings.is_null() {
None
} else {
Some(WrapParamRef::<BrowserSettings, _>::from(arg_settings))
};
let arg_settings = arg_settings.as_mut().map(|arg| arg.as_mut());
let mut arg_extra_info = unsafe { arg_extra_info.as_mut() }.and_then(|ptr| {
let out_extra_info = arg_extra_info;
let mut wrap_extra_info = unsafe { arg_extra_info.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(DictionaryValue(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_extra_info = Some(&mut arg_extra_info);
let arg_extra_info = Some(&mut wrap_extra_info);
let mut arg_no_javascript_access = if arg_no_javascript_access.is_null() {
None
} else {
@@ -20823,7 +20825,7 @@ mod impl_cef_life_span_handler_t {
))
};
let arg_no_javascript_access = arg_no_javascript_access.as_mut().map(|arg| arg.as_mut());
ImplLifeSpanHandler::on_before_popup(
let result = ImplLifeSpanHandler::on_before_popup(
&arg_self_.interface,
arg_browser,
arg_frame,
@@ -20838,7 +20840,17 @@ mod impl_cef_life_span_handler_t {
arg_settings,
arg_extra_info,
arg_no_javascript_access,
)
);
if let (Some(out_client), Some(wrap_client)) = (unsafe { out_client.as_mut() }, wrap_client)
{
*out_client = wrap_client.wrap_result();
}
if let (Some(out_extra_info), Some(wrap_extra_info)) =
(unsafe { out_extra_info.as_mut() }, wrap_extra_info)
{
*out_extra_info = wrap_extra_info.wrap_result();
}
result
}
extern "C" fn on_before_popup_aborted<I: ImplLifeSpanHandler>(
self_: *mut _cef_life_span_handler_t,
@@ -20893,28 +20905,30 @@ mod impl_cef_life_span_handler_t {
Some(WrapParamRef::<WindowInfo, _>::from(arg_window_info))
};
let arg_window_info = arg_window_info.as_mut().map(|arg| arg.as_mut());
let mut arg_client = unsafe { arg_client.as_mut() }.and_then(|ptr| {
let out_client = arg_client;
let mut wrap_client = unsafe { arg_client.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(Client(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_client = Some(&mut arg_client);
let arg_client = Some(&mut wrap_client);
let mut arg_settings = if arg_settings.is_null() {
None
} else {
Some(WrapParamRef::<BrowserSettings, _>::from(arg_settings))
};
let arg_settings = arg_settings.as_mut().map(|arg| arg.as_mut());
let mut arg_extra_info = unsafe { arg_extra_info.as_mut() }.and_then(|ptr| {
let out_extra_info = arg_extra_info;
let mut wrap_extra_info = unsafe { arg_extra_info.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(DictionaryValue(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_extra_info = Some(&mut arg_extra_info);
let arg_extra_info = Some(&mut wrap_extra_info);
let mut arg_use_default_window = if arg_use_default_window.is_null() {
None
} else {
@@ -20923,7 +20937,7 @@ mod impl_cef_life_span_handler_t {
))
};
let arg_use_default_window = arg_use_default_window.as_mut().map(|arg| arg.as_mut());
ImplLifeSpanHandler::on_before_dev_tools_popup(
let result = ImplLifeSpanHandler::on_before_dev_tools_popup(
&arg_self_.interface,
arg_browser,
arg_window_info,
@@ -20931,7 +20945,16 @@ mod impl_cef_life_span_handler_t {
arg_settings,
arg_extra_info,
arg_use_default_window,
)
);
if let (Some(out_client), Some(wrap_client)) = (unsafe { out_client.as_mut() }, wrap_client)
{
*out_client = wrap_client.wrap_result();
}
if let (Some(out_extra_info), Some(wrap_extra_info)) =
(unsafe { out_extra_info.as_mut() }, wrap_extra_info)
{
*out_extra_info = wrap_extra_info.wrap_result();
}
}
extern "C" fn on_after_created<I: ImplLifeSpanHandler>(
self_: *mut _cef_life_span_handler_t,
@@ -30148,28 +30171,34 @@ mod impl_cef_v8_handler_t {
.collect::<Vec<_>>()
});
let arg_arguments = vec_arguments.as_deref();
let mut arg_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
let out_retval = arg_retval;
let mut wrap_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(V8Value(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_retval = Some(&mut arg_retval);
let arg_retval = Some(&mut wrap_retval);
let mut arg_exception = if arg_exception.is_null() {
None
} else {
Some(arg_exception.into())
};
let arg_exception = arg_exception.as_mut();
ImplV8Handler::execute(
let result = ImplV8Handler::execute(
&arg_self_.interface,
arg_name,
arg_object,
arg_arguments,
arg_retval,
arg_exception,
)
);
if let (Some(out_retval), Some(wrap_retval)) = (unsafe { out_retval.as_mut() }, wrap_retval)
{
*out_retval = wrap_retval.wrap_result();
}
result
}
}
impl ImplV8Handler for V8Handler {
@@ -30369,27 +30398,33 @@ mod impl_cef_v8_accessor_t {
let mut arg_object =
unsafe { arg_object.as_mut() }.map(|arg| V8Value(unsafe { RefGuard::from_raw(arg) }));
let arg_object = arg_object.as_mut();
let mut arg_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
let out_retval = arg_retval;
let mut wrap_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(V8Value(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_retval = Some(&mut arg_retval);
let arg_retval = Some(&mut wrap_retval);
let mut arg_exception = if arg_exception.is_null() {
None
} else {
Some(arg_exception.into())
};
let arg_exception = arg_exception.as_mut();
ImplV8Accessor::get(
let result = ImplV8Accessor::get(
&arg_self_.interface,
arg_name,
arg_object,
arg_retval,
arg_exception,
)
);
if let (Some(out_retval), Some(wrap_retval)) = (unsafe { out_retval.as_mut() }, wrap_retval)
{
*out_retval = wrap_retval.wrap_result();
}
result
}
extern "C" fn set<I: ImplV8Accessor>(
self_: *mut _cef_v8_accessor_t,
@@ -30652,27 +30687,33 @@ mod impl_cef_v8_interceptor_t {
let mut arg_object =
unsafe { arg_object.as_mut() }.map(|arg| V8Value(unsafe { RefGuard::from_raw(arg) }));
let arg_object = arg_object.as_mut();
let mut arg_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
let out_retval = arg_retval;
let mut wrap_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(V8Value(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_retval = Some(&mut arg_retval);
let arg_retval = Some(&mut wrap_retval);
let mut arg_exception = if arg_exception.is_null() {
None
} else {
Some(arg_exception.into())
};
let arg_exception = arg_exception.as_mut();
ImplV8Interceptor::byname(
let result = ImplV8Interceptor::byname(
&arg_self_.interface,
arg_name,
arg_object,
arg_retval,
arg_exception,
)
);
if let (Some(out_retval), Some(wrap_retval)) = (unsafe { out_retval.as_mut() }, wrap_retval)
{
*out_retval = wrap_retval.wrap_result();
}
result
}
extern "C" fn get_byindex<I: ImplV8Interceptor>(
self_: *mut _cef_v8_interceptor_t,
@@ -30688,27 +30729,33 @@ mod impl_cef_v8_interceptor_t {
let mut arg_object =
unsafe { arg_object.as_mut() }.map(|arg| V8Value(unsafe { RefGuard::from_raw(arg) }));
let arg_object = arg_object.as_mut();
let mut arg_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
let out_retval = arg_retval;
let mut wrap_retval = unsafe { arg_retval.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(V8Value(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let arg_retval = Some(&mut arg_retval);
let arg_retval = Some(&mut wrap_retval);
let mut arg_exception = if arg_exception.is_null() {
None
} else {
Some(arg_exception.into())
};
let arg_exception = arg_exception.as_mut();
ImplV8Interceptor::byindex(
let result = ImplV8Interceptor::byindex(
&arg_self_.interface,
arg_index,
arg_object,
arg_retval,
arg_exception,
)
);
if let (Some(out_retval), Some(wrap_retval)) = (unsafe { out_retval.as_mut() }, wrap_retval)
{
*out_retval = wrap_retval.wrap_result();
}
result
}
extern "C" fn set_byname<I: ImplV8Interceptor>(
self_: *mut _cef_v8_interceptor_t,

27
update-bindings/src/parse_tree.rs
View File

@@ -821,6 +821,8 @@ impl SignatureRef<'_> {
ty: Some(arg_ty),
} => {
let arg_name = format_ident!("arg_{name}");
let out_name = format_ident!("out_{name}");
let wrap_name = format_ident!("wrap_{name}");
let (modifiers, arg_ty) = (arg_ty.modifiers.as_slice(), &arg_ty.ty);
let ty_tokens = arg_ty.to_token_stream();
let ty_string = ty_tokens.to_string();
@@ -850,14 +852,15 @@ impl SignatureRef<'_> {
let #arg_name = #arg_name.as_mut();
}),
[TypeModifier::MutPtr, TypeModifier::MutPtr] => Some(quote! {
let mut #arg_name = unsafe { #arg_name.as_mut() }.and_then(|ptr| {
let #out_name = #arg_name;
let mut #wrap_name = unsafe { #arg_name.as_mut() }.and_then(|ptr| {
if ptr.is_null() {
None
} else {
Some(#name(unsafe { RefGuard::from_raw(*ptr) }))
}
});
let #arg_name = Some(&mut #arg_name);
let #arg_name = Some(&mut #wrap_name);
}),
_ => None,
}
@@ -1091,6 +1094,26 @@ impl SignatureRef<'_> {
fn unwrap_cef_args(&self, tree: &ParseTree) -> proc_macro2::TokenStream {
let args = self.merge_params(tree).filter_map(|arg| match arg {
MergedParam::Single {
name,
ty: Some(arg_ty),
} => {
let (modifiers, arg_ty) = (arg_ty.modifiers.as_slice(), &arg_ty.ty);
let ty_tokens = arg_ty.to_token_stream();
let ty_string = ty_tokens.to_string();
match modifiers {
[TypeModifier::MutPtr, TypeModifier::MutPtr] if tree.root(&ty_string) == BASE_REF_COUNTED => {
let out_name = format_ident!("out_{name}");
let wrap_name = format_ident!("wrap_{name}");
Some(quote! {
if let (Some(#out_name), Some(#wrap_name)) = (unsafe { #out_name.as_mut() }, #wrap_name) {
*#out_name = #wrap_name.wrap_result();
}
})
}
_ => None,
}
}
MergedParam::Bounded {
count_name,
count_ty: