bcarrella/cef
1
0
Fork 0
mirror of https://bitbucket.org/chromiumembedded/cef synced 2025-03-25 16:30:12 +01:00
Code Issues Packages Projects Releases Wiki Activity

Stop using CefStructBase for POD types (fixes issue #3357)

Browse Source
This commit is contained in:
Marshall Greenblatt 2022-07-14 08:13:29 +00:00
parent 71ef10bb60
commit dad9bf87ef
26 changed files with 322 additions and 745 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/capi/cef_app_capi.h
View File

@ -33,7 +33,7 @@
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
// $hash=665709ecf3ebad59e85285d319eae72197b9766f$
// $hash=84440a43cf4be6728b51919e65c5f33e5736c502$
//
#ifndef CEF_INCLUDE_CAPI_CEF_APP_CAPI_H_
@ -125,7 +125,7 @@ typedef struct _cef_app_t {
// |windows_sandbox_info| parameter is only used on Windows and may be NULL (see
// cef_sandbox_win.h for details).
///
CEF_EXPORT int cef_execute_process(const struct _cef_main_args_t* args,
CEF_EXPORT int cef_execute_process(const cef_main_args_t* args,
cef_app_t* application,
void* windows_sandbox_info);
@ -136,7 +136,7 @@ CEF_EXPORT int cef_execute_process(const struct _cef_main_args_t* args,
// failed. The |windows_sandbox_info| parameter is only used on Windows and may
// be NULL (see cef_sandbox_win.h for details).
///
CEF_EXPORT int cef_initialize(const struct _cef_main_args_t* args,
CEF_EXPORT int cef_initialize(const cef_main_args_t* args,
const struct _cef_settings_t* settings,
cef_app_t* application,
void* windows_sandbox_info);

39
include/capi/cef_browser_capi.h
View File

@ -33,7 +33,7 @@
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
// $hash=b1c1e44e6d3842064ef6e5b9823173f7ec1fcccc$
// $hash=236962db4a3a66eb58546a1eab45dffb2db5178d$
//
#ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_
@ -632,27 +632,25 @@ typedef struct _cef_browser_host_t {
// Send a key event to the browser.
///
void(CEF_CALLBACK* send_key_event)(struct _cef_browser_host_t* self,
const struct _cef_key_event_t* event);
const cef_key_event_t* event);
///
// Send a mouse click event to the browser. The |x| and |y| coordinates are
// relative to the upper-left corner of the view.
///
void(CEF_CALLBACK* send_mouse_click_event)(
struct _cef_browser_host_t* self,
const struct _cef_mouse_event_t* event,
cef_mouse_button_type_t type,
int mouseUp,
int clickCount);
void(CEF_CALLBACK* send_mouse_click_event)(struct _cef_browser_host_t* self,
const cef_mouse_event_t* event,
cef_mouse_button_type_t type,
int mouseUp,
int clickCount);
///
// Send a mouse move event to the browser. The |x| and |y| coordinates are
// relative to the upper-left corner of the view.
///
void(CEF_CALLBACK* send_mouse_move_event)(
struct _cef_browser_host_t* self,
const struct _cef_mouse_event_t* event,
int mouseLeave);
void(CEF_CALLBACK* send_mouse_move_event)(struct _cef_browser_host_t* self,
const cef_mouse_event_t* event,
int mouseLeave);
///
// Send a mouse wheel event to the browser. The |x| and |y| coordinates are
@ -661,17 +659,16 @@ typedef struct _cef_browser_host_t {
// In order to scroll inside select popups with window rendering disabled
// cef_render_handler_t::GetScreenPoint should be implemented properly.
///
void(CEF_CALLBACK* send_mouse_wheel_event)(
struct _cef_browser_host_t* self,
const struct _cef_mouse_event_t* event,
int deltaX,
int deltaY);
void(CEF_CALLBACK* send_mouse_wheel_event)(struct _cef_browser_host_t* self,
const cef_mouse_event_t* event,
int deltaX,
int deltaY);
///
// Send a touch event to the browser for a windowless browser.
///
void(CEF_CALLBACK* send_touch_event)(struct _cef_browser_host_t* self,
const struct _cef_touch_event_t* event);
const cef_touch_event_t* event);
///
// Send a capture lost event to the browser.
@ -780,7 +777,7 @@ typedef struct _cef_browser_host_t {
void(CEF_CALLBACK* drag_target_drag_enter)(
struct _cef_browser_host_t* self,
struct _cef_drag_data_t* drag_data,
const struct _cef_mouse_event_t* event,
const cef_mouse_event_t* event,
cef_drag_operations_mask_t allowed_ops);
///
@ -791,7 +788,7 @@ typedef struct _cef_browser_host_t {
///
void(CEF_CALLBACK* drag_target_drag_over)(
struct _cef_browser_host_t* self,
const struct _cef_mouse_event_t* event,
const cef_mouse_event_t* event,
cef_drag_operations_mask_t allowed_ops);
///
@ -809,7 +806,7 @@ typedef struct _cef_browser_host_t {
// is disabled.
///
void(CEF_CALLBACK* drag_target_drop)(struct _cef_browser_host_t* self,
const struct _cef_mouse_event_t* event);
const cef_mouse_event_t* event);
///
// Call this function when the drag operation started by a

4
include/capi/cef_display_handler_capi.h
View File

@ -33,7 +33,7 @@
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
// $hash=5e52ae520b7eda3595683d428aa578bbc776956b$
// $hash=adb78c1968bb0634d6255e1b5e49b56211da4fa8$
//
#ifndef CEF_INCLUDE_CAPI_CEF_DISPLAY_HANDLER_CAPI_H_
@ -153,7 +153,7 @@ typedef struct _cef_display_handler_t {
struct _cef_browser_t* browser,
cef_cursor_handle_t cursor,
cef_cursor_type_t type,
const struct _cef_cursor_info_t* custom_cursor_info);
const cef_cursor_info_t* custom_cursor_info);
///
// Called when the browser's access to an audio and/or video source has

6
include/capi/cef_keyboard_handler_capi.h
View File

@ -33,7 +33,7 @@
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
// $hash=140d3a3ce78f5e8ab50a24a2fd6377e7a8ea3256$
// $hash=78320536b0ba210f34a42d0508ce3cd023d7b039$
//
#ifndef CEF_INCLUDE_CAPI_CEF_KEYBOARD_HANDLER_CAPI_H_
@ -66,7 +66,7 @@ typedef struct _cef_keyboard_handler_t {
///
int(CEF_CALLBACK* on_pre_key_event)(struct _cef_keyboard_handler_t* self,
struct _cef_browser_t* browser,
const struct _cef_key_event_t* event,
const cef_key_event_t* event,
cef_event_handle_t os_event,
int* is_keyboard_shortcut);
@ -78,7 +78,7 @@ typedef struct _cef_keyboard_handler_t {
///
int(CEF_CALLBACK* on_key_event)(struct _cef_keyboard_handler_t* self,
struct _cef_browser_t* browser,
const struct _cef_key_event_t* event,
const cef_key_event_t* event,
cef_event_handle_t os_event);
} cef_keyboard_handler_t;

4
include/capi/cef_life_span_handler_capi.h
View File

@ -33,7 +33,7 @@
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
// $hash=34a6559587adbd0dc3143989a8c6e49e0664b43e$
// $hash=5d576b7450a269dcd370e65a187b0c9596801162$
//
#ifndef CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_
@ -93,7 +93,7 @@ typedef struct _cef_life_span_handler_t {
const cef_string_t* target_frame_name,
cef_window_open_disposition_t target_disposition,
int user_gesture,
const struct _cef_popup_features_t* popupFeatures,
const cef_popup_features_t* popupFeatures,
struct _cef_window_info_t* windowInfo,
struct _cef_client_t** client,
struct _cef_browser_settings_t* settings,

6
include/capi/cef_render_handler_capi.h
View File

@ -33,7 +33,7 @@
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
// $hash=b0688a7d24b67b74a62841be60217a8e48c7228e$
// $hash=5f56719342d8b07cc9cd9362fc3b506f2b8a0286$
//
#ifndef CEF_INCLUDE_CAPI_CEF_RENDER_HANDLER_CAPI_H_
@ -107,7 +107,7 @@ typedef struct _cef_render_handler_t {
///
int(CEF_CALLBACK* get_screen_info)(struct _cef_render_handler_t* self,
struct _cef_browser_t* browser,
struct _cef_screen_info_t* screen_info);
cef_screen_info_t* screen_info);
///
// Called when the browser wants to show or hide the popup widget. The popup
@ -178,7 +178,7 @@ typedef struct _cef_render_handler_t {
void(CEF_CALLBACK* on_touch_handle_state_changed)(
struct _cef_render_handler_t* self,
struct _cef_browser_t* browser,
const struct _cef_touch_handle_state_t* state);
const cef_touch_handle_state_t* state);
///
// Called when the user starts dragging content in the web view. Contextual

4
include/capi/views/cef_panel_capi.h
View File

@ -33,7 +33,7 @@
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
// $hash=d5311ffa72e57d240f6963b1f45a278041bd33f4$
// $hash=f1d8fe499762ec23c39dea879b9701c6685179ec$
//
#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_PANEL_CAPI_H_
@ -79,7 +79,7 @@ typedef struct _cef_panel_t {
///
struct _cef_box_layout_t*(CEF_CALLBACK* set_to_box_layout)(
struct _cef_panel_t* self,
const struct _cef_box_layout_settings_t* settings);
const cef_box_layout_settings_t* settings);
///
// Get the Layout.

4
include/capi/views/cef_textfield_delegate_capi.h
View File

@ -33,7 +33,7 @@
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
// $hash=44337fe515a5acf51829e1dd00a54f2c1230aba5$
// $hash=8ad9c657c396aa3e9538ff2ab8b0512e55930f03$
//
#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_TEXTFIELD_DELEGATE_CAPI_H_
@ -66,7 +66,7 @@ typedef struct _cef_textfield_delegate_t {
///
int(CEF_CALLBACK* on_key_event)(struct _cef_textfield_delegate_t* self,
struct _cef_textfield_t* textfield,
const struct _cef_key_event_t* event);
const cef_key_event_t* event);
///
// Called after performing a user action that may change |textfield|.

4
include/capi/views/cef_window_delegate_capi.h
View File

@ -33,7 +33,7 @@
// by hand. See the translator.README.txt file in the tools directory for
// more information.
//
// $hash=7f88c6428929c0511ff90b6137efcc4cebcfeae4$
// $hash=742a96590827016b10f21c7779282554b73dfe1a$
//
#ifndef CEF_INCLUDE_CAPI_VIEWS_CEF_WINDOW_DELEGATE_CAPI_H_
@ -163,7 +163,7 @@ typedef struct _cef_window_delegate_t {
///
int(CEF_CALLBACK* on_key_event)(struct _cef_window_delegate_t* self,
struct _cef_window_t* window,
const struct _cef_key_event_t* event);
const cef_key_event_t* event);
} cef_window_delegate_t;
#ifdef __cplusplus

8
include/cef_api_hash.h
View File

@ -42,13 +42,13 @@
// way that may cause binary incompatibility with other builds. The universal
// hash value will change if any platform is affected whereas the platform hash
// values will change only if that particular platform is affected.
#define CEF_API_HASH_UNIVERSAL "1f35577ebd00c5e6cc03a172bb41e3c0d820f3d1"
#define CEF_API_HASH_UNIVERSAL "cb946f2cb8bae48182fd520357fbbda4abc746a7"
#if defined(OS_WIN)
#define CEF_API_HASH_PLATFORM "99f91193dce6b93011526269c4dc5d0c32569b70"
#define CEF_API_HASH_PLATFORM "1982d880b85cd483d4e352796c129586b56638ae"
#elif defined(OS_MAC)
#define CEF_API_HASH_PLATFORM "316e120c0bf151de8145ee3b45ef3451e1ff60dc"
#define CEF_API_HASH_PLATFORM "c34df68ed292774500b591841ccadbc47dddd8c9"
#elif defined(OS_LINUX)
#define CEF_API_HASH_PLATFORM "e061aecbfbf09b9068391bdfcd80c9d5ed1faece"
#define CEF_API_HASH_PLATFORM "b6bb9e9f8d0d7ca5bcd8017a575374e08563d7a6"
#endif
#ifdef __cplusplus

29
include/internal/cef_linux.h
View File

@ -39,32 +39,13 @@
#define CefEventHandle cef_event_handle_t
#define CefWindowHandle cef_window_handle_t
struct CefMainArgsTraits {
typedef cef_main_args_t struct_type;
static inline void init(struct_type* s) {}
static inline void clear(struct_type* s) {}
static inline void set(const struct_type* src,
struct_type* target,
bool copy) {
target->argc = src->argc;
target->argv = src->argv;
}
};
// Class representing CefExecuteProcess arguments.
class CefMainArgs : public CefStructBase<CefMainArgsTraits> {
class CefMainArgs : public cef_main_args_t {
public:
typedef CefStructBase<CefMainArgsTraits> parent;
CefMainArgs() : parent() {}
explicit CefMainArgs(const cef_main_args_t& r) : parent(r) {}
explicit CefMainArgs(const CefMainArgs& r) : parent(r) {}
CefMainArgs(int argc_arg, char** argv_arg) : parent() {
argc = argc_arg;
argv = argv_arg;
}
CefMainArgs() : cef_main_args_t{} {}
CefMainArgs(const cef_main_args_t& r) : cef_main_args_t(r) {}
CefMainArgs(int argc_arg, char** argv_arg)
: cef_main_args_t{argc_arg, argv_arg} {}
};
struct CefWindowInfoTraits {

29
include/internal/cef_mac.h
View File

@ -39,32 +39,13 @@
#define CefEventHandle cef_event_handle_t
#define CefWindowHandle cef_window_handle_t
struct CefMainArgsTraits {
typedef cef_main_args_t struct_type;
static inline void init(struct_type* s) {}
static inline void clear(struct_type* s) {}
static inline void set(const struct_type* src,
struct_type* target,
bool copy) {
target->argc = src->argc;
target->argv = src->argv;
}
};
// Class representing CefExecuteProcess arguments.
class CefMainArgs : public CefStructBase<CefMainArgsTraits> {
class CefMainArgs : public cef_main_args_t {
public:
typedef CefStructBase<CefMainArgsTraits> parent;
CefMainArgs() : parent() {}
explicit CefMainArgs(const cef_main_args_t& r) : parent(r) {}
explicit CefMainArgs(const CefMainArgs& r) : parent(r) {}
CefMainArgs(int argc, char** argv) : parent() {
this->argc = argc;
this->argv = argv;
}
CefMainArgs() : cef_main_args_t{} {}
CefMainArgs(const cef_main_args_t& r) : cef_main_args_t(r) {}
CefMainArgs(int argc_arg, char** argv_arg)
: cef_main_args_t{argc_arg, argv_arg} {}
};
struct CefWindowInfoTraits {

444
include/internal/cef_types_wrappers.h
View File

@ -37,11 +37,12 @@
///
// Template class that provides common functionality for CEF structure wrapping.
// Use only with non-POD types that benefit from referencing unowned members.
///
template <class traits>
class CefStructBase : public traits::struct_type {
public:
typedef typename traits::struct_type struct_type;
using struct_type = typename traits::struct_type;
CefStructBase() : attached_to_(NULL) { Init(); }
virtual ~CefStructBase() {
@ -60,14 +61,6 @@ class CefStructBase : public traits::struct_type {
*this = r;
}
///
// Clear this object's values.
///
void Reset() {
Clear(this);
Init();
}
///
// Attach to the source structure's existing values. DetachTo() can be called
// to insert the values back into the existing structure.
@ -131,29 +124,14 @@ class CefStructBase : public traits::struct_type {
struct_type* attached_to_;
};
struct CefPointTraits {
typedef cef_point_t struct_type;
static inline void init(struct_type* s) {}
static inline void clear(struct_type* s) {}
static inline void set(const struct_type* src,
struct_type* target,
bool copy) {
*target = *src;
}
};
///
// Class representing a point.
///
class CefPoint : public CefStructBase<CefPointTraits> {
class CefPoint : public cef_point_t {
public:
typedef CefStructBase<CefPointTraits> parent;
CefPoint() {}
CefPoint(const cef_point_t& r) : parent(r) {}
CefPoint(int x, int y) { Set(x, y); }
CefPoint() : cef_point_t{} {}
CefPoint(const cef_point_t& r) : cef_point_t(r) {}
CefPoint(int x, int y) : cef_point_t{x, y} {}
bool IsEmpty() const { return x <= 0 && y <= 0; }
void Set(int x_val, int y_val) { x = x_val, y = y_val; }
@ -167,29 +145,15 @@ inline bool operator!=(const CefPoint& a, const CefPoint& b) {
return !(a == b);
}
struct CefRectTraits {
typedef cef_rect_t struct_type;
static inline void init(struct_type* s) {}
static inline void clear(struct_type* s) {}
static inline void set(const struct_type* src,
struct_type* target,
bool copy) {
*target = *src;
}
};
///
// Class representing a rectangle.
///
class CefRect : public CefStructBase<CefRectTraits> {
class CefRect : public cef_rect_t {
public:
typedef CefStructBase<CefRectTraits> parent;
CefRect() {}
CefRect(const cef_rect_t& r) : parent(r) {}
CefRect(int x, int y, int width, int height) { Set(x, y, width, height); }
CefRect() : cef_rect_t{} {}
CefRect(const cef_rect_t& r) : cef_rect_t(r) {}
CefRect(int x, int y, int width, int height)
: cef_rect_t{x, y, width, height} {}
bool IsEmpty() const { return width <= 0 || height <= 0; }
void Set(int x_val, int y_val, int width_val, int height_val) {
@ -216,29 +180,14 @@ inline bool operator!=(const CefRect& a, const CefRect& b) {
return !(a == b);
}
struct CefSizeTraits {
typedef cef_size_t struct_type;
static inline void init(struct_type* s) {}
static inline void clear(struct_type* s) {}
static inline void set(const struct_type* src,
struct_type* target,
bool copy) {
*target = *src;
}
};
///
// Class representing a size.
///
class CefSize : public CefStructBase<CefSizeTraits> {
class CefSize : public cef_size_t {
public:
typedef CefStructBase<CefSizeTraits> parent;
CefSize() {}
CefSize(const cef_size_t& r) : parent(r) {}
CefSize(int width, int height) { Set(width, height); }
CefSize() : cef_size_t{} {}
CefSize(const cef_size_t& r) : cef_size_t(r) {}
CefSize(int width, int height) : cef_size_t{width, height} {}
bool IsEmpty() const { return width <= 0 || height <= 0; }
void Set(int width_val, int height_val) {
@ -254,29 +203,14 @@ inline bool operator!=(const CefSize& a, const CefSize& b) {
return !(a == b);
}
struct CefRangeTraits {
typedef cef_range_t struct_type;
static inline void init(struct_type* s) {}
static inline void clear(struct_type* s) {}
static inline void set(const struct_type* src,
struct_type* target,
bool copy) {
*target = *src;
}
};
///
// Class representing a range.
///
class CefRange : public CefStructBase<CefRangeTraits> {
class CefRange : public cef_range_t {
public:
typedef CefStructBase<CefRangeTraits> parent;
CefRange() {}
CefRange(const cef_range_t& r) : parent(r) {}
CefRange(int from, int to) { Set(from, to); }
CefRange() : cef_range_t{} {}
CefRange(const cef_range_t& r) : cef_range_t(r) {}
CefRange(int from, int to) : cef_range_t{from, to} {}
void Set(int from_val, int to_val) { from = from_val, to = to_val; }
};
@ -289,31 +223,15 @@ inline bool operator!=(const CefRange& a, const CefRange& b) {
return !(a == b);
}
struct CefInsetsTraits {
typedef cef_insets_t struct_type;
static inline void init(struct_type* s) {}
static inline void clear(struct_type* s) {}
static inline void set(const struct_type* src,
struct_type* target,
bool copy) {
*target = *src;
}
};
///
// Class representing insets.
///
class CefInsets : public CefStructBase<CefInsetsTraits> {
class CefInsets : public cef_insets_t {
public:
typedef CefStructBase<CefInsetsTraits> parent;
CefInsets() {}
CefInsets(const cef_insets_t& r) : parent(r) {}
CefInsets(int top, int left, int bottom, int right) {
Set(top, left, bottom, right);
}
CefInsets() : cef_insets_t{} {}
CefInsets(const cef_insets_t& r) : cef_insets_t(r) {}
CefInsets(int top, int left, int bottom, int right)
: cef_insets_t{top, left, bottom, right} {}
void Set(int top_val, int left_val, int bottom_val, int right_val) {
top = top_val, left = left_val, bottom = bottom_val, right = right_val;
@ -329,31 +247,16 @@ inline bool operator!=(const CefInsets& a, const CefInsets& b) {
return !(a == b);
}
struct CefDraggableRegionTraits {
typedef cef_draggable_region_t struct_type;
static inline void init(struct_type* s) {}
static inline void clear(struct_type* s) {}
static inline void set(const struct_type* src,
struct_type* target,
bool copy) {
*target = *src;
}
};
///
// Class representing a draggable region.
///
class CefDraggableRegion : public CefStructBase<CefDraggableRegionTraits> {
class CefDraggableRegion : public cef_draggable_region_t {
public:
typedef CefStructBase<CefDraggableRegionTraits> parent;
CefDraggableRegion() {}
CefDraggableRegion(const cef_draggable_region_t& r) : parent(r) {}
CefDraggableRegion(const CefRect& bounds, bool draggable) {
Set(bounds, draggable);
}
CefDraggableRegion() : cef_draggable_region_t{} {}
CefDraggableRegion(const cef_draggable_region_t& r)
: cef_draggable_region_t(r) {}
CefDraggableRegion(const cef_rect_t& bounds, bool draggable)
: cef_draggable_region_t{bounds, draggable} {}
void Set(const CefRect& bounds_val, bool draggable_val) {
bounds = bounds_val, draggable = draggable_val;
@ -370,44 +273,22 @@ inline bool operator!=(const CefDraggableRegion& a,
return !(a == b);
}
struct CefScreenInfoTraits {
typedef cef_screen_info_t struct_type;
static inline void init(struct_type* s) {}
static inline void clear(struct_type* s) {}
static inline void set(const struct_type* src,
struct_type* target,
bool copy) {
target->device_scale_factor = src->device_scale_factor;
target->depth = src->depth;
target->depth_per_component = src->depth_per_component;
target->is_monochrome = src->is_monochrome;
target->rect = src->rect;
target->available_rect = src->available_rect;
}
};
///
// Class representing the virtual screen information for use when window
// rendering is disabled.
///
class CefScreenInfo : public CefStructBase<CefScreenInfoTraits> {
class CefScreenInfo : public cef_screen_info_t {
public:
typedef CefStructBase<CefScreenInfoTraits> parent;
CefScreenInfo() {}
CefScreenInfo(const cef_screen_info_t& r) : parent(r) {}
CefScreenInfo() : cef_screen_info_t{} {}
CefScreenInfo(const cef_screen_info_t& r) : cef_screen_info_t(r) {}
CefScreenInfo(float device_scale_factor,
int depth,
int depth_per_component,
bool is_monochrome,
const CefRect& rect,
const CefRect& available_rect) {
Set(device_scale_factor, depth, depth_per_component, is_monochrome, rect,
available_rect);
}
const cef_rect_t& rect,
const cef_rect_t& available_rect)
: cef_screen_info_t{device_scale_factor, depth, depth_per_component,
is_monochrome, rect, available_rect} {}
void Set(float device_scale_factor_val,
int depth_val,
@ -424,109 +305,44 @@ class CefScreenInfo : public CefStructBase<CefScreenInfoTraits> {
}
};
struct CefKeyEventTraits {
typedef cef_key_event_t struct_type;
static inline void init(struct_type* s) {}
static inline void clear(struct_type* s) {}
static inline void set(const struct_type* src,
struct_type* target,
bool copy) {
target->type = src->type;
target->modifiers = src->modifiers;
target->windows_key_code = src->windows_key_code;
target->native_key_code = src->native_key_code;
target->is_system_key = src->is_system_key;
target->character = src->character;
target->unmodified_character = src->unmodified_character;
target->focus_on_editable_field = src->focus_on_editable_field;
}
};
///
// Class representing a a keyboard event.
///
typedef CefStructBase<CefKeyEventTraits> CefKeyEvent;
struct CefMouseEventTraits {
typedef cef_mouse_event_t struct_type;
static inline void init(struct_type* s) {}
static inline void clear(struct_type* s) {}
static inline void set(const struct_type* src,
struct_type* target,
bool copy) {
target->x = src->x;
target->y = src->y;
target->modifiers = src->modifiers;
}
class CefKeyEvent : public cef_key_event_t {
public:
CefKeyEvent() : cef_key_event_t{} {}
CefKeyEvent(const cef_key_event_t& r) : cef_key_event_t(r) {}
};
///
// Class representing a mouse event.
///
typedef CefStructBase<CefMouseEventTraits> CefMouseEvent;
struct CefTouchEventTraits {
typedef cef_touch_event_t struct_type;
static inline void init(struct_type* s) {}
static inline void clear(struct_type* s) {}
static inline void set(const struct_type* src,
struct_type* target,
bool copy) {
*target = *src;
}
class CefMouseEvent : public cef_mouse_event_t {
public:
CefMouseEvent() : cef_mouse_event_t{} {}
CefMouseEvent(const cef_mouse_event_t& r) : cef_mouse_event_t(r) {}
};
///
// Class representing a touch event.
///
typedef CefStructBase<CefTouchEventTraits> CefTouchEvent;
struct CefPopupFeaturesTraits {
typedef cef_popup_features_t struct_type;
static inline void init(struct_type* s) {
s->menuBarVisible = true;
s->statusBarVisible = true;
s->toolBarVisible = true;
s->scrollbarsVisible = true;
}
static inline void clear(struct_type* s) {}
static inline void set(const struct_type* src,
struct_type* target,
bool copy) {
target->x = src->x;
target->xSet = src->xSet;
target->y = src->y;
target->ySet = src->ySet;
target->width = src->width;
target->widthSet = src->widthSet;
target->height = src->height;
target->heightSet = src->heightSet;
target->menuBarVisible = src->menuBarVisible;
target->statusBarVisible = src->statusBarVisible;
target->toolBarVisible = src->toolBarVisible;
target->scrollbarsVisible = src->scrollbarsVisible;
}
class CefTouchEvent : public cef_touch_event_t {
public:
CefTouchEvent() : cef_touch_event_t{} {}
CefTouchEvent(const cef_touch_event_t& r) : cef_touch_event_t(r) {}
};
///
// Class representing popup window features.
///
typedef CefStructBase<CefPopupFeaturesTraits> CefPopupFeatures;
class CefPopupFeatures : public cef_popup_features_t {
public:
CefPopupFeatures() : cef_popup_features_t{} {}
CefPopupFeatures(const cef_popup_features_t& r) : cef_popup_features_t(r) {}
};
struct CefSettingsTraits {
typedef cef_settings_t struct_type;
using struct_type = cef_settings_t;
static inline void init(struct_type* s) { s->size = sizeof(struct_type); }
@ -610,10 +426,10 @@ struct CefSettingsTraits {
///
// Class representing initialization settings.
///
typedef CefStructBase<CefSettingsTraits> CefSettings;
using CefSettings = CefStructBase<CefSettingsTraits>;
struct CefRequestContextSettingsTraits {
typedef cef_request_context_settings_t struct_type;
using struct_type = cef_request_context_settings_t;
static inline void init(struct_type* s) { s->size = sizeof(struct_type); }
@ -645,11 +461,11 @@ struct CefRequestContextSettingsTraits {
///
// Class representing request context initialization settings.
///
typedef CefStructBase<CefRequestContextSettingsTraits>
CefRequestContextSettings;
using CefRequestContextSettings =
CefStructBase<CefRequestContextSettingsTraits>;
struct CefBrowserSettingsTraits {
typedef cef_browser_settings_t struct_type;
using struct_type = cef_browser_settings_t;
static inline void init(struct_type* s) { s->size = sizeof(struct_type); }
@ -721,10 +537,10 @@ struct CefBrowserSettingsTraits {
///
// Class representing browser initialization settings.
///
typedef CefStructBase<CefBrowserSettingsTraits> CefBrowserSettings;
using CefBrowserSettings = CefStructBase<CefBrowserSettingsTraits>;
struct CefURLPartsTraits {
typedef cef_urlparts_t struct_type;
using struct_type = cef_urlparts_t;
static inline void init(struct_type* s) {}
@ -763,31 +579,15 @@ struct CefURLPartsTraits {
///
// Class representing a URL's component parts.
///
typedef CefStructBase<CefURLPartsTraits> CefURLParts;
struct CefTimeTraits {
typedef cef_time_t struct_type;
static inline void init(struct_type* s) {}
static inline void clear(struct_type* s) {}
static inline void set(const struct_type* src,
struct_type* target,
bool copy) {
*target = *src;
}
};
using CefURLParts = CefStructBase<CefURLPartsTraits>;
///
// Class representing a time.
///
class CefTime : public CefStructBase<CefTimeTraits> {
class CefTime : public cef_time_t {
public:
typedef CefStructBase<CefTimeTraits> parent;
CefTime() {}
CefTime(const cef_time_t& r) : parent(r) {}
CefTime() : cef_time_t{} {}
CefTime(const cef_time_t& r) : cef_time_t(r) {}
explicit CefTime(time_t r) { SetTimeT(r); }
explicit CefTime(double r) { SetDoubleT(r); }
@ -820,27 +620,18 @@ class CefTime : public CefStructBase<CefTimeTraits> {
}
};
struct CefTouchHandleStateTraits {
typedef cef_touch_handle_state_t struct_type;
static inline void init(struct_type* s) {}
static inline void clear(struct_type* s) {}
static inline void set(const struct_type* src,
struct_type* target,
bool copy) {
*target = *src;
}
};
///
// Class representing the state of a touch handle.
///
typedef CefStructBase<CefTouchHandleStateTraits> CefTouchHandleState;
class CefTouchHandleState : public cef_touch_handle_state_t {
public:
CefTouchHandleState() : cef_touch_handle_state_t{} {}
CefTouchHandleState(const cef_touch_handle_state_t& r)
: cef_touch_handle_state_t(r) {}
};
struct CefCookieTraits {
typedef cef_cookie_t struct_type;
using struct_type = cef_cookie_t;
static inline void init(struct_type* s) {}
@ -872,29 +663,19 @@ struct CefCookieTraits {
///
// Class representing a cookie.
///
typedef CefStructBase<CefCookieTraits> CefCookie;
struct CefCursorInfoTraits {
typedef cef_cursor_info_t struct_type;
static inline void init(struct_type* s) {}
static inline void clear(struct_type* s) {}
static inline void set(const struct_type* src,
struct_type* target,
bool copy) {
*target = *src;
}
};
using CefCookie = CefStructBase<CefCookieTraits>;
///
// Class representing cursor information.
///
typedef CefStructBase<CefCursorInfoTraits> CefCursorInfo;
class CefCursorInfo : public cef_cursor_info_t {
public:
CefCursorInfo() : cef_cursor_info_t{} {}
CefCursorInfo(const cef_cursor_info_t& r) : cef_cursor_info_t(r) {}
};
struct CefPdfPrintSettingsTraits {
typedef cef_pdf_print_settings_t struct_type;
using struct_type = cef_pdf_print_settings_t;
static inline void init(struct_type* s) {}
@ -933,67 +714,40 @@ struct CefPdfPrintSettingsTraits {
///
// Class representing PDF print settings
///
typedef CefStructBase<CefPdfPrintSettingsTraits> CefPdfPrintSettings;
struct CefBoxLayoutSettingsTraits {
typedef cef_box_layout_settings_t struct_type;
static inline void init(struct_type* s) {}
static inline void clear(struct_type* s) {}
static inline void set(const struct_type* src,
struct_type* target,
bool copy) {
*target = *src;
}
};
using CefPdfPrintSettings = CefStructBase<CefPdfPrintSettingsTraits>;
///
// Class representing CefBoxLayout settings.
///
typedef CefStructBase<CefBoxLayoutSettingsTraits> CefBoxLayoutSettings;
struct CefCompositionUnderlineTraits {
typedef cef_composition_underline_t struct_type;
static inline void init(struct_type* s) {}
static inline void clear(struct_type* s) {}
static inline void set(const struct_type* src,
struct_type* target,
bool copy) {
*target = *src;
}
class CefBoxLayoutSettings : public cef_box_layout_settings_t {
public:
CefBoxLayoutSettings() : cef_box_layout_settings_t{} {}
CefBoxLayoutSettings(const cef_box_layout_settings_t& r)
: cef_box_layout_settings_t(r) {}
};
///
// Class representing IME composition underline.
///
typedef CefStructBase<CefCompositionUnderlineTraits> CefCompositionUnderline;
struct CefAudioParametersTraits {
typedef cef_audio_parameters_t struct_type;
static inline void init(struct_type* s) {}
static inline void clear(struct_type* s) {}
static inline void set(const struct_type* src,
struct_type* target,
bool copy) {
*target = *src;
}
class CefCompositionUnderline : public cef_composition_underline_t {
public:
CefCompositionUnderline() : cef_composition_underline_t{} {}
CefCompositionUnderline(const cef_composition_underline_t& r)
: cef_composition_underline_t(r) {}
};
///
// Class representing CefAudioParameters settings
///
typedef CefStructBase<CefAudioParametersTraits> CefAudioParameters;
class CefAudioParameters : public cef_audio_parameters_t {
public:
CefAudioParameters() : cef_audio_parameters_t{} {}
CefAudioParameters(const cef_audio_parameters_t& r)
: cef_audio_parameters_t(r) {}
};
struct CefMediaSinkDeviceInfoTraits {
typedef cef_media_sink_device_info_t struct_type;
using struct_type = cef_media_sink_device_info_t;
static inline void init(struct_type* s) {}
@ -1016,6 +770,6 @@ struct CefMediaSinkDeviceInfoTraits {
///
// Class representing MediaSink device info.
///
typedef CefStructBase<CefMediaSinkDeviceInfoTraits> CefMediaSinkDeviceInfo;
using CefMediaSinkDeviceInfo = CefStructBase<CefMediaSinkDeviceInfoTraits>;
#endif // CEF_INCLUDE_INTERNAL_CEF_TYPES_WRAPPERS_H_

24
include/internal/cef_win.h
View File

@ -41,28 +41,12 @@
#define CefEventHandle cef_event_handle_t
#define CefWindowHandle cef_window_handle_t
struct CefMainArgsTraits {
typedef cef_main_args_t struct_type;
static inline void init(struct_type* s) {}
static inline void clear(struct_type* s) {}
static inline void set(const struct_type* src,
struct_type* target,
bool copy) {
target->instance = src->instance;
}
};
// Class representing CefExecuteProcess arguments.
class CefMainArgs : public CefStructBase<CefMainArgsTraits> {
class CefMainArgs : public cef_main_args_t {
public:
typedef CefStructBase<CefMainArgsTraits> parent;
CefMainArgs() : parent() {}
explicit CefMainArgs(const cef_main_args_t& r) : parent(r) {}
explicit CefMainArgs(const CefMainArgs& r) : parent(r) {}
explicit CefMainArgs(HINSTANCE hInstance) : parent() { instance = hInstance; }
CefMainArgs() : cef_main_args_t{} {}
CefMainArgs(const cef_main_args_t& r) : cef_main_args_t(r) {}
explicit CefMainArgs(HINSTANCE hInstance) : cef_main_args_t{hInstance} {}
};
struct CefWindowInfoTraits {

133
libcef_dll/cpptoc/browser_host_cpptoc.cc
View File

@ -9,7 +9,7 @@
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=65c260e354b6dc85bf121b60081eff450b043542$
// $hash=3a9153112764b124ef7b38c7a29970c84a0b6b30$
//
#include "libcef_dll/cpptoc/browser_host_cpptoc.h"
@ -760,9 +760,8 @@ browser_host_send_external_begin_frame(struct _cef_browser_host_t* self) {
CefBrowserHostCppToC::Get(self)->SendExternalBeginFrame();
}
void CEF_CALLBACK
browser_host_send_key_event(struct _cef_browser_host_t* self,
const struct _cef_key_event_t* event) {
void CEF_CALLBACK browser_host_send_key_event(struct _cef_browser_host_t* self,
const cef_key_event_t* event) {
shutdown_checker::AssertNotShutdown();
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@ -770,27 +769,21 @@ browser_host_send_key_event(struct _cef_browser_host_t* self,
DCHECK(self);
if (!self)
return;
// Verify param: event; type: struct_byref_const
// Verify param: event; type: simple_byref_const
DCHECK(event);
if (!event)
return;
if (!template_util::has_valid_size(event)) {
NOTREACHED() << "invalid event->[base.]size";
return;
}
// Translate param: event; type: struct_byref_const
CefKeyEvent eventObj;
if (event)
eventObj.Set(*event, false);
// Translate param: event; type: simple_byref_const
CefKeyEvent eventVal = event ? *event : CefKeyEvent();
// Execute
CefBrowserHostCppToC::Get(self)->SendKeyEvent(eventObj);
CefBrowserHostCppToC::Get(self)->SendKeyEvent(eventVal);
}
void CEF_CALLBACK
browser_host_send_mouse_click_event(struct _cef_browser_host_t* self,
const struct _cef_mouse_event_t* event,
const cef_mouse_event_t* event,
cef_mouse_button_type_t type,
int mouseUp,
int clickCount) {
@ -801,28 +794,22 @@ browser_host_send_mouse_click_event(struct _cef_browser_host_t* self,
DCHECK(self);
if (!self)
return;
// Verify param: event; type: struct_byref_const
// Verify param: event; type: simple_byref_const
DCHECK(event);
if (!event)
return;
if (!template_util::has_valid_size(event)) {
NOTREACHED() << "invalid event->[base.]size";
return;
}
// Translate param: event; type: struct_byref_const
CefMouseEvent eventObj;
if (event)
eventObj.Set(*event, false);
// Translate param: event; type: simple_byref_const
CefMouseEvent eventVal = event ? *event : CefMouseEvent();
// Execute
CefBrowserHostCppToC::Get(self)->SendMouseClickEvent(
eventObj, type, mouseUp ? true : false, clickCount);
eventVal, type, mouseUp ? true : false, clickCount);
}
void CEF_CALLBACK
browser_host_send_mouse_move_event(struct _cef_browser_host_t* self,
const struct _cef_mouse_event_t* event,
const cef_mouse_event_t* event,
int mouseLeave) {
shutdown_checker::AssertNotShutdown();
@ -831,28 +818,22 @@ browser_host_send_mouse_move_event(struct _cef_browser_host_t* self,
DCHECK(self);
if (!self)
return;
// Verify param: event; type: struct_byref_const
// Verify param: event; type: simple_byref_const
DCHECK(event);
if (!event)
return;
if (!template_util::has_valid_size(event)) {
NOTREACHED() << "invalid event->[base.]size";
return;
}
// Translate param: event; type: struct_byref_const
CefMouseEvent eventObj;
if (event)
eventObj.Set(*event, false);
// Translate param: event; type: simple_byref_const
CefMouseEvent eventVal = event ? *event : CefMouseEvent();
// Execute
CefBrowserHostCppToC::Get(self)->SendMouseMoveEvent(
eventObj, mouseLeave ? true : false);
eventVal, mouseLeave ? true : false);
}
void CEF_CALLBACK
browser_host_send_mouse_wheel_event(struct _cef_browser_host_t* self,
const struct _cef_mouse_event_t* event,
const cef_mouse_event_t* event,
int deltaX,
int deltaY) {
shutdown_checker::AssertNotShutdown();
@ -862,28 +843,22 @@ browser_host_send_mouse_wheel_event(struct _cef_browser_host_t* self,
DCHECK(self);
if (!self)
return;
// Verify param: event; type: struct_byref_const
// Verify param: event; type: simple_byref_const
DCHECK(event);
if (!event)
return;
if (!template_util::has_valid_size(event)) {
NOTREACHED() << "invalid event->[base.]size";
return;
}
// Translate param: event; type: struct_byref_const
CefMouseEvent eventObj;
if (event)
eventObj.Set(*event, false);
// Translate param: event; type: simple_byref_const
CefMouseEvent eventVal = event ? *event : CefMouseEvent();
// Execute
CefBrowserHostCppToC::Get(self)->SendMouseWheelEvent(eventObj, deltaX,
CefBrowserHostCppToC::Get(self)->SendMouseWheelEvent(eventVal, deltaX,
deltaY);
}
void CEF_CALLBACK
browser_host_send_touch_event(struct _cef_browser_host_t* self,
const struct _cef_touch_event_t* event) {
const cef_touch_event_t* event) {
shutdown_checker::AssertNotShutdown();
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@ -891,22 +866,16 @@ browser_host_send_touch_event(struct _cef_browser_host_t* self,
DCHECK(self);
if (!self)
return;
// Verify param: event; type: struct_byref_const
// Verify param: event; type: simple_byref_const
DCHECK(event);
if (!event)
return;
if (!template_util::has_valid_size(event)) {
NOTREACHED() << "invalid event->[base.]size";
return;
}
// Translate param: event; type: struct_byref_const
CefTouchEvent eventObj;
if (event)
eventObj.Set(*event, false);
// Translate param: event; type: simple_byref_const
CefTouchEvent eventVal = event ? *event : CefTouchEvent();
// Execute
CefBrowserHostCppToC::Get(self)->SendTouchEvent(eventObj);
CefBrowserHostCppToC::Get(self)->SendTouchEvent(eventVal);
}
void CEF_CALLBACK
@ -1073,7 +1042,7 @@ browser_host_ime_cancel_composition(struct _cef_browser_host_t* self) {
void CEF_CALLBACK
browser_host_drag_target_drag_enter(struct _cef_browser_host_t* self,
struct _cef_drag_data_t* drag_data,
const struct _cef_mouse_event_t* event,
const cef_mouse_event_t* event,
cef_drag_operations_mask_t allowed_ops) {
shutdown_checker::AssertNotShutdown();
@ -1086,28 +1055,22 @@ browser_host_drag_target_drag_enter(struct _cef_browser_host_t* self,
DCHECK(drag_data);
if (!drag_data)
return;
// Verify param: event; type: struct_byref_const
// Verify param: event; type: simple_byref_const
DCHECK(event);
if (!event)
return;
if (!template_util::has_valid_size(event)) {
NOTREACHED() << "invalid event->[base.]size";
return;
}
// Translate param: event; type: struct_byref_const
CefMouseEvent eventObj;
if (event)
eventObj.Set(*event, false);
// Translate param: event; type: simple_byref_const
CefMouseEvent eventVal = event ? *event : CefMouseEvent();
// Execute
CefBrowserHostCppToC::Get(self)->DragTargetDragEnter(
CefDragDataCppToC::Unwrap(drag_data), eventObj, allowed_ops);
CefDragDataCppToC::Unwrap(drag_data), eventVal, allowed_ops);
}
void CEF_CALLBACK
browser_host_drag_target_drag_over(struct _cef_browser_host_t* self,
const struct _cef_mouse_event_t* event,
const cef_mouse_event_t* event,
cef_drag_operations_mask_t allowed_ops) {
shutdown_checker::AssertNotShutdown();
@ -1116,22 +1079,16 @@ browser_host_drag_target_drag_over(struct _cef_browser_host_t* self,
DCHECK(self);
if (!self)
return;
// Verify param: event; type: struct_byref_const
// Verify param: event; type: simple_byref_const
DCHECK(event);
if (!event)
return;
if (!template_util::has_valid_size(event)) {
NOTREACHED() << "invalid event->[base.]size";
return;
}
// Translate param: event; type: struct_byref_const
CefMouseEvent eventObj;
if (event)
eventObj.Set(*event, false);
// Translate param: event; type: simple_byref_const
CefMouseEvent eventVal = event ? *event : CefMouseEvent();
// Execute
CefBrowserHostCppToC::Get(self)->DragTargetDragOver(eventObj, allowed_ops);
CefBrowserHostCppToC::Get(self)->DragTargetDragOver(eventVal, allowed_ops);
}
void CEF_CALLBACK
@ -1150,7 +1107,7 @@ browser_host_drag_target_drag_leave(struct _cef_browser_host_t* self) {
void CEF_CALLBACK
browser_host_drag_target_drop(struct _cef_browser_host_t* self,
const struct _cef_mouse_event_t* event) {
const cef_mouse_event_t* event) {
shutdown_checker::AssertNotShutdown();
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@ -1158,22 +1115,16 @@ browser_host_drag_target_drop(struct _cef_browser_host_t* self,
DCHECK(self);
if (!self)
return;
// Verify param: event; type: struct_byref_const
// Verify param: event; type: simple_byref_const
DCHECK(event);
if (!event)
return;
if (!template_util::has_valid_size(event)) {
NOTREACHED() << "invalid event->[base.]size";
return;
}
// Translate param: event; type: struct_byref_const
CefMouseEvent eventObj;
if (event)
eventObj.Set(*event, false);
// Translate param: event; type: simple_byref_const
CefMouseEvent eventVal = event ? *event : CefMouseEvent();
// Execute
CefBrowserHostCppToC::Get(self)->DragTargetDrop(eventObj);
CefBrowserHostCppToC::Get(self)->DragTargetDrop(eventVal);
}
void CEF_CALLBACK

30
libcef_dll/cpptoc/display_handler_cpptoc.cc
View File

@ -9,14 +9,13 @@
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=b492dccf2a5ddb50f50fe1783d8cacd3080714a5$
// $hash=53bd2b4cabde53903719d240c7c9f6000cbf1a37$
//
#include "libcef_dll/cpptoc/display_handler_cpptoc.h"
#include "libcef_dll/ctocpp/browser_ctocpp.h"
#include "libcef_dll/ctocpp/frame_ctocpp.h"
#include "libcef_dll/shutdown_checker.h"
#include "libcef_dll/template_util.h"
#include "libcef_dll/transfer_util.h"
namespace {
@ -253,12 +252,12 @@ display_handler_on_loading_progress_change(struct _cef_display_handler_t* self,
CefBrowserCToCpp::Wrap(browser), progress);
}
int CEF_CALLBACK display_handler_on_cursor_change(
struct _cef_display_handler_t* self,
cef_browser_t* browser,
cef_cursor_handle_t cursor,
cef_cursor_type_t type,
const struct _cef_cursor_info_t* custom_cursor_info) {
int CEF_CALLBACK
display_handler_on_cursor_change(struct _cef_display_handler_t* self,
cef_browser_t* browser,
cef_cursor_handle_t cursor,
cef_cursor_type_t type,
const cef_cursor_info_t* custom_cursor_info) {
shutdown_checker::AssertNotShutdown();
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@ -270,23 +269,18 @@ int CEF_CALLBACK display_handler_on_cursor_change(
DCHECK(browser);
if (!browser)
return 0;
// Verify param: custom_cursor_info; type: struct_byref_const
// Verify param: custom_cursor_info; type: simple_byref_const
DCHECK(custom_cursor_info);
if (!custom_cursor_info)
return 0;
if (!template_util::has_valid_size(custom_cursor_info)) {
NOTREACHED() << "invalid custom_cursor_info->[base.]size";
return 0;
}
// Translate param: custom_cursor_info; type: struct_byref_const
CefCursorInfo custom_cursor_infoObj;
if (custom_cursor_info)
custom_cursor_infoObj.Set(*custom_cursor_info, false);
// Translate param: custom_cursor_info; type: simple_byref_const
CefCursorInfo custom_cursor_infoVal =
custom_cursor_info ? *custom_cursor_info : CefCursorInfo();
// Execute
bool _retval = CefDisplayHandlerCppToC::Get(self)->OnCursorChange(
CefBrowserCToCpp::Wrap(browser), cursor, type, custom_cursor_infoObj);
CefBrowserCToCpp::Wrap(browser), cursor, type, custom_cursor_infoVal);
// Return type: bool
return _retval;

35
libcef_dll/cpptoc/keyboard_handler_cpptoc.cc
View File

@ -9,13 +9,12 @@
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=8830306303ec402f4aaa21007719300c320ae77d$
// $hash=37d878ee8dbf3a48362059e64a0cafa8138bacfc$
//
#include "libcef_dll/cpptoc/keyboard_handler_cpptoc.h"
#include "libcef_dll/ctocpp/browser_ctocpp.h"
#include "libcef_dll/shutdown_checker.h"
#include "libcef_dll/template_util.h"
namespace {
@ -24,7 +23,7 @@ namespace {
int CEF_CALLBACK
keyboard_handler_on_pre_key_event(struct _cef_keyboard_handler_t* self,
cef_browser_t* browser,
const struct _cef_key_event_t* event,
const cef_key_event_t* event,
cef_event_handle_t os_event,
int* is_keyboard_shortcut) {
shutdown_checker::AssertNotShutdown();
@ -38,30 +37,24 @@ keyboard_handler_on_pre_key_event(struct _cef_keyboard_handler_t* self,
DCHECK(browser);
if (!browser)
return 0;
// Verify param: event; type: struct_byref_const
// Verify param: event; type: simple_byref_const
DCHECK(event);
if (!event)
return 0;
if (!template_util::has_valid_size(event)) {
NOTREACHED() << "invalid event->[base.]size";
return 0;
}
// Verify param: is_keyboard_shortcut; type: bool_byaddr
DCHECK(is_keyboard_shortcut);
if (!is_keyboard_shortcut)
return 0;
// Translate param: event; type: struct_byref_const
CefKeyEvent eventObj;
if (event)
eventObj.Set(*event, false);
// Translate param: event; type: simple_byref_const
CefKeyEvent eventVal = event ? *event : CefKeyEvent();
// Translate param: is_keyboard_shortcut; type: bool_byaddr
bool is_keyboard_shortcutBool =
(is_keyboard_shortcut && *is_keyboard_shortcut) ? true : false;
// Execute
bool _retval = CefKeyboardHandlerCppToC::Get(self)->OnPreKeyEvent(
CefBrowserCToCpp::Wrap(browser), eventObj, os_event,
CefBrowserCToCpp::Wrap(browser), eventVal, os_event,
&is_keyboard_shortcutBool);
// Restore param: is_keyboard_shortcut; type: bool_byaddr
@ -75,7 +68,7 @@ keyboard_handler_on_pre_key_event(struct _cef_keyboard_handler_t* self,
int CEF_CALLBACK
keyboard_handler_on_key_event(struct _cef_keyboard_handler_t* self,
cef_browser_t* browser,
const struct _cef_key_event_t* event,
const cef_key_event_t* event,
cef_event_handle_t os_event) {
shutdown_checker::AssertNotShutdown();
@ -88,23 +81,17 @@ keyboard_handler_on_key_event(struct _cef_keyboard_handler_t* self,
DCHECK(browser);
if (!browser)
return 0;
// Verify param: event; type: struct_byref_const
// Verify param: event; type: simple_byref_const
DCHECK(event);
if (!event)
return 0;
if (!template_util::has_valid_size(event)) {
NOTREACHED() << "invalid event->[base.]size";
return 0;
}
// Translate param: event; type: struct_byref_const
CefKeyEvent eventObj;
if (event)
eventObj.Set(*event, false);
// Translate param: event; type: simple_byref_const
CefKeyEvent eventVal = event ? *event : CefKeyEvent();
// Execute
bool _retval = CefKeyboardHandlerCppToC::Get(self)->OnKeyEvent(
CefBrowserCToCpp::Wrap(browser), eventObj, os_event);
CefBrowserCToCpp::Wrap(browser), eventVal, os_event);
// Return type: bool
return _retval;

19
libcef_dll/cpptoc/life_span_handler_cpptoc.cc
View File

@ -9,7 +9,7 @@
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=b7e2c44f09e8ec252b6481378d8fc8b23ba13f60$
// $hash=a98eb406c58de0e631b408cebd2b2cb0fcdfef7d$
//
#include "libcef_dll/cpptoc/life_span_handler_cpptoc.h"
@ -32,7 +32,7 @@ int CEF_CALLBACK life_span_handler_on_before_popup(
const cef_string_t* target_frame_name,
cef_window_open_disposition_t target_disposition,
int user_gesture,
const struct _cef_popup_features_t* popupFeatures,
const cef_popup_features_t* popupFeatures,
cef_window_info_t* windowInfo,
cef_client_t** client,
struct _cef_browser_settings_t* settings,
@ -53,14 +53,10 @@ int CEF_CALLBACK life_span_handler_on_before_popup(
DCHECK(frame);
if (!frame)
return 0;
// Verify param: popupFeatures; type: struct_byref_const
// Verify param: popupFeatures; type: simple_byref_const
DCHECK(popupFeatures);
if (!popupFeatures)
return 0;
if (!template_util::has_valid_size(popupFeatures)) {
NOTREACHED() << "invalid popupFeatures->[base.]size";
return 0;
}
// Verify param: windowInfo; type: struct_byref
DCHECK(windowInfo);
if (!windowInfo)
@ -91,10 +87,9 @@ int CEF_CALLBACK life_span_handler_on_before_popup(
return 0;
// Unverified params: target_url, target_frame_name
// Translate param: popupFeatures; type: struct_byref_const
CefPopupFeatures popupFeaturesObj;
if (popupFeatures)
popupFeaturesObj.Set(*popupFeatures, false);
// Translate param: popupFeatures; type: simple_byref_const
CefPopupFeatures popupFeaturesVal =
popupFeatures ? *popupFeatures : CefPopupFeatures();
// Translate param: windowInfo; type: struct_byref
CefWindowInfo windowInfoObj;
if (windowInfo)
@ -121,7 +116,7 @@ int CEF_CALLBACK life_span_handler_on_before_popup(
bool _retval = CefLifeSpanHandlerCppToC::Get(self)->OnBeforePopup(
CefBrowserCToCpp::Wrap(browser), CefFrameCToCpp::Wrap(frame),
CefString(target_url), CefString(target_frame_name), target_disposition,
user_gesture ? true : false, popupFeaturesObj, windowInfoObj, clientPtr,
user_gesture ? true : false, popupFeaturesVal, windowInfoObj, clientPtr,
settingsObj, extra_infoPtr, &no_javascript_accessBool);
// Restore param: windowInfo; type: struct_byref

39
libcef_dll/cpptoc/render_handler_cpptoc.cc
View File

@ -9,7 +9,7 @@
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=6671ca3d639065c49adfc8ceac4c58833344d558$
// $hash=bae1669c71f95662417884910215fb4cba94c5a5$
//
#include "libcef_dll/cpptoc/render_handler_cpptoc.h"
@ -17,7 +17,6 @@
#include "libcef_dll/ctocpp/browser_ctocpp.h"
#include "libcef_dll/ctocpp/drag_data_ctocpp.h"
#include "libcef_dll/shutdown_checker.h"
#include "libcef_dll/template_util.h"
namespace {
@ -158,7 +157,7 @@ render_handler_get_screen_point(struct _cef_render_handler_t* self,
int CEF_CALLBACK
render_handler_get_screen_info(struct _cef_render_handler_t* self,
cef_browser_t* browser,
struct _cef_screen_info_t* screen_info) {
cef_screen_info_t* screen_info) {
shutdown_checker::AssertNotShutdown();
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@ -170,27 +169,21 @@ render_handler_get_screen_info(struct _cef_render_handler_t* self,
DCHECK(browser);
if (!browser)
return 0;
// Verify param: screen_info; type: struct_byref
// Verify param: screen_info; type: simple_byref
DCHECK(screen_info);
if (!screen_info)
return 0;
if (!template_util::has_valid_size(screen_info)) {
NOTREACHED() << "invalid screen_info->[base.]size";
return 0;
}
// Translate param: screen_info; type: struct_byref
CefScreenInfo screen_infoObj;
if (screen_info)
screen_infoObj.AttachTo(*screen_info);
// Translate param: screen_info; type: simple_byref
CefScreenInfo screen_infoVal = screen_info ? *screen_info : CefScreenInfo();
// Execute
bool _retval = CefRenderHandlerCppToC::Get(self)->GetScreenInfo(
CefBrowserCToCpp::Wrap(browser), screen_infoObj);
CefBrowserCToCpp::Wrap(browser), screen_infoVal);
// Restore param: screen_info; type: struct_byref
// Restore param: screen_info; type: simple_byref
if (screen_info)
screen_infoObj.DetachTo(*screen_info);
*screen_info = screen_infoVal;
// Return type: bool
return _retval;
@ -365,7 +358,7 @@ render_handler_get_touch_handle_size(struct _cef_render_handler_t* self,
void CEF_CALLBACK render_handler_on_touch_handle_state_changed(
struct _cef_render_handler_t* self,
cef_browser_t* browser,
const struct _cef_touch_handle_state_t* state) {
const cef_touch_handle_state_t* state) {
shutdown_checker::AssertNotShutdown();
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@ -377,23 +370,17 @@ void CEF_CALLBACK render_handler_on_touch_handle_state_changed(
DCHECK(browser);
if (!browser)
return;
// Verify param: state; type: struct_byref_const
// Verify param: state; type: simple_byref_const
DCHECK(state);
if (!state)
return;
if (!template_util::has_valid_size(state)) {
NOTREACHED() << "invalid state->[base.]size";
return;
}
// Translate param: state; type: struct_byref_const
CefTouchHandleState stateObj;
if (state)
stateObj.Set(*state, false);
// Translate param: state; type: simple_byref_const
CefTouchHandleState stateVal = state ? *state : CefTouchHandleState();
// Execute
CefRenderHandlerCppToC::Get(self)->OnTouchHandleStateChanged(
CefBrowserCToCpp::Wrap(browser), stateObj);
CefBrowserCToCpp::Wrap(browser), stateVal);
}
int CEF_CALLBACK

20
libcef_dll/cpptoc/views/panel_cpptoc.cc
View File

@ -9,7 +9,7 @@
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=4d101afc4f559c6f0375ad4016e5575ab88bf61f$
// $hash=8b6386137895a8c202890fd6a5d239eddd9e400e$
//
#include "libcef_dll/cpptoc/views/panel_cpptoc.h"
@ -25,7 +25,6 @@
#include "libcef_dll/ctocpp/views/panel_delegate_ctocpp.h"
#include "libcef_dll/ctocpp/views/view_delegate_ctocpp.h"
#include "libcef_dll/shutdown_checker.h"
#include "libcef_dll/template_util.h"
// GLOBAL FUNCTIONS - Body may be edited by hand.
@ -84,7 +83,7 @@ panel_set_to_fill_layout(struct _cef_panel_t* self) {
cef_box_layout_t* CEF_CALLBACK
panel_set_to_box_layout(struct _cef_panel_t* self,
const struct _cef_box_layout_settings_t* settings) {
const cef_box_layout_settings_t* settings) {
shutdown_checker::AssertNotShutdown();
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@ -92,23 +91,18 @@ panel_set_to_box_layout(struct _cef_panel_t* self,
DCHECK(self);
if (!self)
return NULL;
// Verify param: settings; type: struct_byref_const
// Verify param: settings; type: simple_byref_const
DCHECK(settings);
if (!settings)
return NULL;
if (!template_util::has_valid_size(settings)) {
NOTREACHED() << "invalid settings->[base.]size";
return NULL;
}
// Translate param: settings; type: struct_byref_const
CefBoxLayoutSettings settingsObj;
if (settings)
settingsObj.Set(*settings, false);
// Translate param: settings; type: simple_byref_const
CefBoxLayoutSettings settingsVal =
settings ? *settings : CefBoxLayoutSettings();
// Execute
CefRefPtr<CefBoxLayout> _retval =
CefPanelCppToC::Get(self)->SetToBoxLayout(settingsObj);
CefPanelCppToC::Get(self)->SetToBoxLayout(settingsVal);
// Return type: refptr_same
return CefBoxLayoutCppToC::Wrap(_retval);

19
libcef_dll/cpptoc/views/textfield_delegate_cpptoc.cc
View File

@ -9,14 +9,13 @@
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=1a7a3f0cd61dab86aae86ca54e5554671d1850b7$
// $hash=be4a8b1aeaa7b2c6701c9cc5445285a20027c44b$
//
#include "libcef_dll/cpptoc/views/textfield_delegate_cpptoc.h"
#include "libcef_dll/ctocpp/views/textfield_ctocpp.h"
#include "libcef_dll/ctocpp/views/view_ctocpp.h"
#include "libcef_dll/shutdown_checker.h"
#include "libcef_dll/template_util.h"
namespace {
@ -25,7 +24,7 @@ namespace {
int CEF_CALLBACK
textfield_delegate_on_key_event(struct _cef_textfield_delegate_t* self,
cef_textfield_t* textfield,
const struct _cef_key_event_t* event) {
const cef_key_event_t* event) {
shutdown_checker::AssertNotShutdown();
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@ -37,23 +36,17 @@ textfield_delegate_on_key_event(struct _cef_textfield_delegate_t* self,
DCHECK(textfield);
if (!textfield)
return 0;
// Verify param: event; type: struct_byref_const
// Verify param: event; type: simple_byref_const
DCHECK(event);
if (!event)
return 0;
if (!template_util::has_valid_size(event)) {
NOTREACHED() << "invalid event->[base.]size";
return 0;
}
// Translate param: event; type: struct_byref_const
CefKeyEvent eventObj;
if (event)
eventObj.Set(*event, false);
// Translate param: event; type: simple_byref_const
CefKeyEvent eventVal = event ? *event : CefKeyEvent();
// Execute
bool _retval = CefTextfieldDelegateCppToC::Get(self)->OnKeyEvent(
CefTextfieldCToCpp::Wrap(textfield), eventObj);
CefTextfieldCToCpp::Wrap(textfield), eventVal);
// Return type: bool
return _retval;

20
libcef_dll/cpptoc/views/window_cpptoc.cc
View File

@ -9,7 +9,7 @@
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=cf3e61b4caedb8689bcc3a0a5b21b1897eef5220$
// $hash=32506537b2118f2d16285dc09174ae721447adc2$
//
#include "libcef_dll/cpptoc/views/window_cpptoc.h"
@ -29,7 +29,6 @@
#include "libcef_dll/ctocpp/views/view_delegate_ctocpp.h"
#include "libcef_dll/ctocpp/views/window_delegate_ctocpp.h"
#include "libcef_dll/shutdown_checker.h"
#include "libcef_dll/template_util.h"
// GLOBAL FUNCTIONS - Body may be edited by hand.
@ -691,7 +690,7 @@ window_set_to_fill_layout(struct _cef_panel_t* self) {
cef_box_layout_t* CEF_CALLBACK
window_set_to_box_layout(struct _cef_panel_t* self,
const struct _cef_box_layout_settings_t* settings) {
const cef_box_layout_settings_t* settings) {
shutdown_checker::AssertNotShutdown();
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@ -699,24 +698,19 @@ window_set_to_box_layout(struct _cef_panel_t* self,
DCHECK(self);
if (!self)
return NULL;
// Verify param: settings; type: struct_byref_const
// Verify param: settings; type: simple_byref_const
DCHECK(settings);
if (!settings)
return NULL;
if (!template_util::has_valid_size(settings)) {
NOTREACHED() << "invalid settings->[base.]size";
return NULL;
}
// Translate param: settings; type: struct_byref_const
CefBoxLayoutSettings settingsObj;
if (settings)
settingsObj.Set(*settings, false);
// Translate param: settings; type: simple_byref_const
CefBoxLayoutSettings settingsVal =
settings ? *settings : CefBoxLayoutSettings();
// Execute
CefRefPtr<CefBoxLayout> _retval =
CefWindowCppToC::Get(reinterpret_cast<cef_window_t*>(self))
->SetToBoxLayout(settingsObj);
->SetToBoxLayout(settingsVal);
// Return type: refptr_same
return CefBoxLayoutCppToC::Wrap(_retval);

19
libcef_dll/cpptoc/views/window_delegate_cpptoc.cc
View File

@ -9,14 +9,13 @@
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=60fce570867addbf622a0f74422d225f23942e4d$
// $hash=2ecdf3e890e54e962286430f350c5b49249a9a9e$
//
#include "libcef_dll/cpptoc/views/window_delegate_cpptoc.h"
#include "libcef_dll/ctocpp/views/view_ctocpp.h"
#include "libcef_dll/ctocpp/views/window_ctocpp.h"
#include "libcef_dll/shutdown_checker.h"
#include "libcef_dll/template_util.h"
namespace {
@ -317,7 +316,7 @@ window_delegate_on_accelerator(struct _cef_window_delegate_t* self,
int CEF_CALLBACK
window_delegate_on_key_event(struct _cef_window_delegate_t* self,
cef_window_t* window,
const struct _cef_key_event_t* event) {
const cef_key_event_t* event) {
shutdown_checker::AssertNotShutdown();
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
@ -329,23 +328,17 @@ window_delegate_on_key_event(struct _cef_window_delegate_t* self,
DCHECK(window);
if (!window)
return 0;
// Verify param: event; type: struct_byref_const
// Verify param: event; type: simple_byref_const
DCHECK(event);
if (!event)
return 0;
if (!template_util::has_valid_size(event)) {
NOTREACHED() << "invalid event->[base.]size";
return 0;
}
// Translate param: event; type: struct_byref_const
CefKeyEvent eventObj;
if (event)
eventObj.Set(*event, false);
// Translate param: event; type: simple_byref_const
CefKeyEvent eventVal = event ? *event : CefKeyEvent();
// Execute
bool _retval = CefWindowDelegateCppToC::Get(self)->OnKeyEvent(
CefWindowCToCpp::Wrap(window), eventObj);
CefWindowCToCpp::Wrap(window), eventVal);
// Return type: bool
return _retval;

34
libcef_dll/libcef_dll.cc
View File

@ -9,7 +9,7 @@
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=3ec7e1f78d91004790dda03a97832aa37c33d0f9$
// $hash=6f8f05ae0e6a0b4122af70f11e6f14f2c3bbff6f$
//
#include "include/capi/cef_app_capi.h"
@ -56,48 +56,38 @@
// GLOBAL FUNCTIONS - Body may be edited by hand.
CEF_EXPORT int cef_execute_process(const struct _cef_main_args_t* args,
CEF_EXPORT int cef_execute_process(const cef_main_args_t* args,
struct _cef_app_t* application,
void* windows_sandbox_info) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
// Verify param: args; type: struct_byref_const
// Verify param: args; type: simple_byref_const
DCHECK(args);
if (!args)
return 0;
if (!template_util::has_valid_size(args)) {
NOTREACHED() << "invalid args->[base.]size";
return 0;
}
// Unverified params: application, windows_sandbox_info
// Translate param: args; type: struct_byref_const
CefMainArgs argsObj;
if (args)
argsObj.Set(*args, false);
// Translate param: args; type: simple_byref_const
CefMainArgs argsVal = args ? *args : CefMainArgs();
// Execute
int _retval = CefExecuteProcess(argsObj, CefAppCToCpp::Wrap(application),
int _retval = CefExecuteProcess(argsVal, CefAppCToCpp::Wrap(application),
windows_sandbox_info);
// Return type: simple
return _retval;
}
CEF_EXPORT int cef_initialize(const struct _cef_main_args_t* args,
CEF_EXPORT int cef_initialize(const cef_main_args_t* args,
const struct _cef_settings_t* settings,
struct _cef_app_t* application,
void* windows_sandbox_info) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
// Verify param: args; type: struct_byref_const
// Verify param: args; type: simple_byref_const
DCHECK(args);
if (!args)
return 0;
if (!template_util::has_valid_size(args)) {
NOTREACHED() << "invalid args->[base.]size";
return 0;
}
// Verify param: settings; type: struct_byref_const
DCHECK(settings);
if (!settings)
@ -108,10 +98,8 @@ CEF_EXPORT int cef_initialize(const struct _cef_main_args_t* args,
}
// Unverified params: application, windows_sandbox_info
// Translate param: args; type: struct_byref_const
CefMainArgs argsObj;
if (args)
argsObj.Set(*args, false);
// Translate param: args; type: simple_byref_const
CefMainArgs argsVal = args ? *args : CefMainArgs();
// Translate param: settings; type: struct_byref_const
CefSettings settingsObj;
if (settings)
@ -119,7 +107,7 @@ CEF_EXPORT int cef_initialize(const struct _cef_main_args_t* args,
// Execute
bool _retval =
CefInitialize(argsObj, settingsObj, CefAppCToCpp::Wrap(application),
CefInitialize(argsVal, settingsObj, CefAppCToCpp::Wrap(application),
windows_sandbox_info);
// Return type: bool

57
libcef_dll/wrapper/libcef_dll_dylib.cc
View File

@ -9,7 +9,7 @@
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=8faeb658bc18088c0fb3160fb354574592a17f37$
// $hash=c2c4aa508db66d7b185c4f9ed9a89f1cd65107c1$
//
#include <dlfcn.h>
@ -546,7 +546,7 @@ int cef_unload_library() {
}
NO_SANITIZE("cfi-icall")
int cef_execute_process(const struct _cef_main_args_t* args,
int cef_execute_process(const cef_main_args_t* args,
struct _cef_app_t* application,
void* windows_sandbox_info) {
return g_libcef_pointers.cef_execute_process(args, application,
@ -554,7 +554,7 @@ int cef_execute_process(const struct _cef_main_args_t* args,
}
NO_SANITIZE("cfi-icall")
int cef_initialize(const struct _cef_main_args_t* args,
int cef_initialize(const cef_main_args_t* args,
const struct _cef_settings_t* settings,
struct _cef_app_t* application,
void* windows_sandbox_info) {
@ -677,8 +677,8 @@ int cef_create_url(const struct _cef_urlparts_t* parts, cef_string_t* url) {
}
NO_SANITIZE("cfi-icall")
cef_string_userfree_t
cef_format_url_for_security_display(const cef_string_t* origin_url) {
cef_string_userfree_t cef_format_url_for_security_display(
const cef_string_t* origin_url) {
return g_libcef_pointers.cef_format_url_for_security_display(origin_url);
}
@ -940,10 +940,9 @@ void cef_server_create(const cef_string_t* address,
}
NO_SANITIZE("cfi-icall")
struct
_cef_shared_process_message_builder_t* cef_shared_process_message_builder_create(
const cef_string_t* name,
size_t byte_size) {
struct _cef_shared_process_message_builder_t*
cef_shared_process_message_builder_create(const cef_string_t* name,
size_t byte_size) {
return g_libcef_pointers.cef_shared_process_message_builder_create(name,
byte_size);
}
@ -1141,54 +1140,46 @@ struct _cef_translator_test_t* cef_translator_test_create() {
}
NO_SANITIZE("cfi-icall")
struct
_cef_translator_test_ref_ptr_library_t* cef_translator_test_ref_ptr_library_create(
int value) {
struct _cef_translator_test_ref_ptr_library_t*
cef_translator_test_ref_ptr_library_create(int value) {
return g_libcef_pointers.cef_translator_test_ref_ptr_library_create(value);
}
NO_SANITIZE("cfi-icall")
struct
_cef_translator_test_ref_ptr_library_child_t* cef_translator_test_ref_ptr_library_child_create(
int value,
int other_value) {
struct _cef_translator_test_ref_ptr_library_child_t*
cef_translator_test_ref_ptr_library_child_create(int value, int other_value) {
return g_libcef_pointers.cef_translator_test_ref_ptr_library_child_create(
value, other_value);
}
NO_SANITIZE("cfi-icall")
struct
_cef_translator_test_ref_ptr_library_child_child_t* cef_translator_test_ref_ptr_library_child_child_create(
int value,
int other_value,
int other_other_value) {
struct _cef_translator_test_ref_ptr_library_child_child_t*
cef_translator_test_ref_ptr_library_child_child_create(int value,
int other_value,
int other_other_value) {
return g_libcef_pointers
.cef_translator_test_ref_ptr_library_child_child_create(
value, other_value, other_other_value);
}
NO_SANITIZE("cfi-icall")
struct
_cef_translator_test_scoped_library_t* cef_translator_test_scoped_library_create(
int value) {
struct _cef_translator_test_scoped_library_t*
cef_translator_test_scoped_library_create(int value) {
return g_libcef_pointers.cef_translator_test_scoped_library_create(value);
}
NO_SANITIZE("cfi-icall")
struct
_cef_translator_test_scoped_library_child_t* cef_translator_test_scoped_library_child_create(
int value,
int other_value) {
struct _cef_translator_test_scoped_library_child_t*
cef_translator_test_scoped_library_child_create(int value, int other_value) {
return g_libcef_pointers.cef_translator_test_scoped_library_child_create(
value, other_value);
}
NO_SANITIZE("cfi-icall")
struct
_cef_translator_test_scoped_library_child_child_t* cef_translator_test_scoped_library_child_child_create(
int value,
int other_value,
int other_other_value) {
struct _cef_translator_test_scoped_library_child_child_t*
cef_translator_test_scoped_library_child_child_create(int value,
int other_value,
int other_other_value) {
return g_libcef_pointers
.cef_translator_test_scoped_library_child_child_create(value, other_value,
other_other_value);

31
tools/cef_parser.py
View File

@ -394,21 +394,34 @@ _simpletypes = {
'char* const': ['char* const', 'NULL'],
'cef_color_t': ['cef_color_t', '0'],
'cef_json_parser_error_t': ['cef_json_parser_error_t', 'JSON_NO_ERROR'],
'CefCursorHandle': ['cef_cursor_handle_t', 'kNullCursorHandle'],
'CefAudioParameters': ['cef_audio_parameters_t', 'CefAudioParameters()'],
'CefBoxLayoutSettings': [
'cef_box_layout_settings_t', 'CefBoxLayoutSettings()'
],
'CefCompositionUnderline': [
'cef_composition_underline_t', 'CefCompositionUnderline()'
],
'CefEventHandle': ['cef_event_handle_t', 'kNullEventHandle'],
'CefWindowHandle': ['cef_window_handle_t', 'kNullWindowHandle'],
'CefInsets': ['cef_insets_t', 'CefInsets()'],
'CefPoint': ['cef_point_t', 'CefPoint()'],
'CefRect': ['cef_rect_t', 'CefRect()'],
'CefSize': ['cef_size_t', 'CefSize()'],
'CefRange': ['cef_range_t', 'CefRange()'],
'CefCursorHandle': ['cef_cursor_handle_t', 'kNullCursorHandle'],
'CefCursorInfo': ['cef_cursor_info_t', 'CefCursorInfo()'],
'CefDraggableRegion': ['cef_draggable_region_t', 'CefDraggableRegion()'],
'CefEventHandle': ['cef_event_handle_t', 'kNullEventHandle'],
'CefInsets': ['cef_insets_t', 'CefInsets()'],
'CefKeyEvent': ['cef_key_event_t', 'CefKeyEvent()'],
'CefMainArgs': ['cef_main_args_t', 'CefMainArgs()'],
'CefMouseEvent': ['cef_mouse_event_t', 'CefMouseEvent()'],
'CefPoint': ['cef_point_t', 'CefPoint()'],
'CefPopupFeatures': ['cef_popup_features_t', 'CefPopupFeatures()'],
'CefRange': ['cef_range_t', 'CefRange()'],
'CefRect': ['cef_rect_t', 'CefRect()'],
'CefScreenInfo': ['cef_screen_info_t', 'CefScreenInfo()'],
'CefSize': ['cef_size_t', 'CefSize()'],
'CefTouchEvent': ['cef_touch_event_t', 'CefTouchEvent()'],
'CefTouchHandleState': [
'cef_touch_handle_state_t', 'CefTouchHandleState()'
],
'CefThreadId': ['cef_thread_id_t', 'TID_UI'],
'CefTime': ['cef_time_t', 'CefTime()'],
'CefAudioParameters': ['cef_audio_parameters_t', 'CefAudioParameters()']
'CefWindowHandle': ['cef_window_handle_t', 'kNullWindowHandle'],
}