diff --git a/CefGlue.Interop.Gen/include/cef_api_versions.h b/CefGlue.Interop.Gen/include/cef_api_versions.h index b20e742..c6265d3 100644 --- a/CefGlue.Interop.Gen/include/cef_api_versions.h +++ b/CefGlue.Interop.Gen/include/cef_api_versions.h @@ -279,7 +279,7 @@ #define CEF_API_HASH_15000 "210767725a6feb2e4becd3956b648cab6a006712" #endif -// Next version last updated July 10, 2026. +// Next version last updated August 04, 2026. #define CEF_API_VERSION_999998 999998 #if defined(OS_WIN) #define CEF_API_HASH_999998 "71146b4350a01d3805e7ea990eb034e6ef4d53db" @@ -289,14 +289,14 @@ #define CEF_API_HASH_999998 "210767725a6feb2e4becd3956b648cab6a006712" #endif -// Experimental version last updated July 10, 2026. +// Experimental version last updated August 04, 2026. #define CEF_API_VERSION_999999 999999 #if defined(OS_WIN) -#define CEF_API_HASH_999999 "c63591fb321ac707f8710f296a8ae1ec05a575db" +#define CEF_API_HASH_999999 "98f8c0d3b73ee1ade0ea70e5e67f48116fa2b3f3" #elif defined(OS_MAC) -#define CEF_API_HASH_999999 "0934859000c911cdd75907f63f2ef8e485706e5b" +#define CEF_API_HASH_999999 "f7f0a19b29e2f1cb7dec42ee3ef26fc571da8a8e" #elif defined(OS_LINUX) -#define CEF_API_HASH_999999 "a5d187477e0cbe23eb1043c2f1868582b7018260" +#define CEF_API_HASH_999999 "8aba464ae9af72f65a1584199dd81fc3557c75b1" #endif // Oldest supported CEF version. diff --git a/CefGlue.Interop.Gen/include/cef_browser.h b/CefGlue.Interop.Gen/include/cef_browser.h index 0c27c15..5f0dc83 100644 --- a/CefGlue.Interop.Gen/include/cef_browser.h +++ b/CefGlue.Interop.Gen/include/cef_browser.h @@ -744,6 +744,22 @@ class CefBrowserHost : public virtual CefBaseRefCounted { /*--cef()--*/ virtual void SendExternalBeginFrame() = 0; +#if CEF_API_ADDED(CEF_EXPERIMENTAL) + /// + /// Release a surface leased by CefRenderHandler::OnAcceleratedPaint. + /// |surface_id| is the value delivered in CefAcceleratedPaintInfo. This + /// method is only used when window rendering is disabled. + /// + /// While a lease is held the surface is not returned to the capture pool and + /// its texture handle stays valid, so it may be sampled after the paint + /// callback returns. The pool is small, so release each surface as soon as it + /// is no longer in use or capture will stall. Releasing an id that is unknown + /// or already released does nothing. + /// + /*--cef(added=experimental)--*/ + virtual void ReleaseAcceleratedPaintSurface(uint64_t surface_id) = 0; +#endif + /// /// Send a key event to the browser. /// diff --git a/CefGlue.Interop.Gen/include/cef_render_handler.h b/CefGlue.Interop.Gen/include/cef_render_handler.h index 332a113..1052550 100644 --- a/CefGlue.Interop.Gen/include/cef_render_handler.h +++ b/CefGlue.Interop.Gen/include/cef_render_handler.h @@ -158,13 +158,16 @@ class CefRenderHandler : public virtual CefBaseRefCounted { /// opened with Metal or OpenGL, and on Linux it contains several planes, each /// with an fd to the underlying system native buffer. /// - /// The underlying implementation uses a pool to deliver frames. As a result, - /// the handle may differ every frame depending on how many frames are - /// in-progress. The handle's resource cannot be cached and cannot be accessed - /// outside of this callback. It should be reopened each time this callback is - /// executed and the contents should be copied to a texture owned by the - /// client application. The contents of |info| will be released back to the - /// pool after this callback returns. + /// The underlying implementation uses a pool to deliver frames, so the handle + /// may differ every frame depending on how many frames are in-progress. + /// + /// |info| carries a surface_id identifying a lease on the surface. While the + /// lease is held the surface is not returned to the pool and its handle stays + /// valid, so the handle may be opened once and sampled well after this + /// callback returns; there is no need to copy the contents here. Release the + /// lease with CefBrowserHost::ReleaseAcceleratedPaintSurface once the surface + /// is no longer in use. The pool is small, so a client that does not release + /// promptly will stall capture. /// /*--cef()--*/ virtual void OnAcceleratedPaint(CefRefPtr browser, diff --git a/CefGlue.Interop.Gen/include/cef_version.h b/CefGlue.Interop.Gen/include/cef_version.h index fe2d653..d869698 100644 --- a/CefGlue.Interop.Gen/include/cef_version.h +++ b/CefGlue.Interop.Gen/include/cef_version.h @@ -35,18 +35,18 @@ #ifndef CEF_INCLUDE_CEF_VERSION_H_ #define CEF_INCLUDE_CEF_VERSION_H_ -#define CEF_VERSION "150.0.11+gb887805+chromium-150.0.7871.115" +#define CEF_VERSION "150.0.23-2026-08-04-surface-lease.3556+ge7ab2e1+chromium-150.0.7871.187" #define CEF_VERSION_MAJOR 150 #define CEF_VERSION_MINOR 0 -#define CEF_VERSION_PATCH 11 -#define CEF_COMMIT_NUMBER 3544 -#define CEF_COMMIT_HASH "b88780525f76c1c1d67d30b87e3b16bb37955175" +#define CEF_VERSION_PATCH 23 +#define CEF_COMMIT_NUMBER 3556 +#define CEF_COMMIT_HASH "e7ab2e15e1973d318458b5882a448be97ebd08c7" #define COPYRIGHT_YEAR 2026 #define CHROME_VERSION_MAJOR 150 #define CHROME_VERSION_MINOR 0 #define CHROME_VERSION_BUILD 7871 -#define CHROME_VERSION_PATCH 115 +#define CHROME_VERSION_PATCH 187 #define CEF_SANDBOX_COMPAT_HASH "6c5b35ad81055c14" diff --git a/CefGlue.Interop.Gen/include/internal/cef_types_osr.h b/CefGlue.Interop.Gen/include/internal/cef_types_osr.h index 0664cfa..d71d3f5 100644 --- a/CefGlue.Interop.Gen/include/internal/cef_types_osr.h +++ b/CefGlue.Interop.Gen/include/internal/cef_types_osr.h @@ -34,6 +34,7 @@ #include #include +#include "include/cef_api_hash.h" #include "include/internal/cef_types_geometry.h" #ifdef __cplusplus @@ -112,6 +113,19 @@ typedef struct _cef_accelerated_paint_info_common_t { /// uint8_t has_capture_counter; +#if CEF_API_ADDED(CEF_EXPERIMENTAL) + /// + /// Opaque identifier for a leased surface, or 0 when no lease was granted. + /// + /// While a lease is held the surface is not returned to the capture pool and + /// its texture handle stays valid, so the client may keep sampling it after + /// the paint callback returns. A lease must be released once the surface is + /// no longer in use; the pool is small, and holding leases indefinitely + /// stalls capture. + /// + uint64_t surface_id; +#endif + } cef_accelerated_paint_info_common_t; #ifdef __cplusplus diff --git a/CefGlue.Interop.Gen/include/internal/cef_types_win.h b/CefGlue.Interop.Gen/include/internal/cef_types_win.h index a812c33..1d8e4c7 100644 --- a/CefGlue.Interop.Gen/include/internal/cef_types_win.h +++ b/CefGlue.Interop.Gen/include/internal/cef_types_win.h @@ -127,8 +127,9 @@ typedef struct _cef_window_info_t { /// /// Structure containing shared texture information for the OnAcceleratedPaint -/// callback. Resources will be released to the underlying pool for reuse when -/// the callback returns from client code. +/// callback. Resources are returned to the underlying pool when the lease +/// identified by |extra.surface_id| is released, or when the callback returns +/// if no lease was granted. /// typedef struct _cef_accelerated_paint_info_t { /// diff --git a/CefGlue.Interop.Gen/make_interop.py b/CefGlue.Interop.Gen/make_interop.py index b79839e..d8bd6c0 100644 --- a/CefGlue.Interop.Gen/make_interop.py +++ b/CefGlue.Interop.Gen/make_interop.py @@ -163,6 +163,29 @@ def make_struct_file(cls): 'body': indent + ('\n'+indent).join(body) } +def get_added_version(func): + """The API version that introduced a method, as a sortable number. + + A method with no 'added' attribute belongs to the original surface and sorts first. + 'experimental' is the highest version there is, so it sorts last.""" + added = func.get_attrib('added') + if added is None: + return 0 + if added == 'experimental': + return 999999 + return int(added) + +def sort_by_added_version(funcs): + """Order struct members the way CEF's own translator does: by the version that added them, then by + declaration order. + + This is what keeps the C API layout stable across versions. A member added later is appended after every + member of earlier versions, wherever its C++ declaration happens to sit, so a client built against an older + version still finds the members it knows at the offsets it expects. Following declaration order instead puts + a newly added member in the middle of the struct and silently shifts every member below it, which reads as + calls landing on the wrong function pointer at runtime.""" + return sorted(funcs, key=get_added_version) + def get_funcs(cls, base = True, inherited = True): funcs = [] @@ -184,7 +207,7 @@ def get_funcs(cls, base = True, inherited = True): current_cls = classes.pop() if current_cls is None: break - for func in current_cls.get_virtual_funcs(): + for func in sort_by_added_version(current_cls.get_virtual_funcs()): funcs.append( get_func_parts(func, i) ) i += 1 @@ -823,7 +846,7 @@ def make_version_cs(content, api_hash_content, api_versions_content): result.append('public const int CHROME_VERSION_PATCH = %s;' % __get_version_constant(content, "CHROME_VERSION_PATCH")) result.append(""); - api_details = get_cef_api_details(api_versions_content) + api_details = get_cef_api_details(api_versions_content, api_hash_content) result.append('public const int CEF_API_VERSION = %s;' % api_details["API_VERSION"]) result.append('public const string CEF_API_HASH_PLATFORM_WIN = "%s";' % api_details["OS_WIN"]) result.append('public const string CEF_API_HASH_PLATFORM_MACOS = "%s";' % api_details["OS_MAC"]) @@ -850,17 +873,28 @@ def make_version_cs(content, api_hash_content, api_versions_content): 'body': indent + ('\n'+indent).join(body) } -def get_cef_api_details(content): +def get_cef_api_details(content, api_hash_content): + """Pick the API version these bindings declare, and the hashes that go with it. + + The version is not bookkeeping: a client announces it by calling cef_api_hash(version) before initializing, + and the library then builds its C API structs to match. Announce an explicit version and every method added + since is compiled out of those structs, so the field a binding reads is a different method's pointer, or + past the end of the struct. Calls into it crash. + + So the version has to match the headers the interop was generated from. We generate against the experimental + surface, because our own additions live there: experimental is where CEF puts API that is not yet frozen into + a numbered version. Explicit versions buy forward and backward compatibility across a range of CEF releases, + which is worth having and which we give up here deliberately, since we ship the libcef we bind against. + """ lines = content.splitlines() - - # Find the last API version - match_version = re.search(r"#define\s+CEF_API_VERSION_LAST\s+(CEF_API_VERSION_\d+)", content) + + # The number lives in cef_api_hash.h; the hashes keyed by it live in cef_api_versions.h. + match_version = re.search(r"#define\s+CEF_API_VERSION_EXPERIMENTAL\s+(\d+)", api_hash_content) if not match_version: - raise ValueError("CEF_API_VERSION_LAST not found in the file") - - last_version = match_version.group(1) - last_version_number = last_version.split('_')[-1] - + raise ValueError("CEF_API_VERSION_EXPERIMENTAL not found in cef_api_hash.h") + + last_version_number = match_version.group(1) + # Extract OS-specific hashes details = { "API_VERSION": last_version_number } current_os = None diff --git a/CefGlue/Interop/Classes.g/cef_browser_host_t.g.cs b/CefGlue/Interop/Classes.g/cef_browser_host_t.g.cs index bdcfeb4..969bfe5 100644 --- a/CefGlue/Interop/Classes.g/cef_browser_host_t.g.cs +++ b/CefGlue/Interop/Classes.g/cef_browser_host_t.g.cs @@ -51,7 +51,6 @@ internal unsafe struct cef_browser_host_t internal IntPtr _notify_screen_info_changed; internal IntPtr _invalidate; internal IntPtr _send_external_begin_frame; - internal IntPtr _release_accelerated_paint_surface; internal IntPtr _send_key_event; internal IntPtr _send_mouse_click_event; internal IntPtr _send_mouse_move_event; @@ -82,6 +81,7 @@ internal unsafe struct cef_browser_host_t internal IntPtr _execute_chrome_command; internal IntPtr _is_render_process_unresponsive; internal IntPtr _get_runtime_style; + internal IntPtr _release_accelerated_paint_surface; internal IntPtr _set_ax_viewport_collapse; // CreateBrowser @@ -348,12 +348,6 @@ internal unsafe struct cef_browser_host_t #endif private delegate void send_external_begin_frame_delegate(cef_browser_host_t* self); - [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)] - #if !DEBUG - [SuppressUnmanagedCodeSecurity] - #endif - private delegate void release_accelerated_paint_surface_delegate(cef_browser_host_t* self, ulong surface_id); - [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)] #if !DEBUG [SuppressUnmanagedCodeSecurity] @@ -534,6 +528,12 @@ internal unsafe struct cef_browser_host_t #endif private delegate CefRuntimeStyle get_runtime_style_delegate(cef_browser_host_t* self); + [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)] + #if !DEBUG + [SuppressUnmanagedCodeSecurity] + #endif + private delegate void release_accelerated_paint_surface_delegate(cef_browser_host_t* self, ulong surface_id); + [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)] #if !DEBUG [SuppressUnmanagedCodeSecurity] @@ -1254,533 +1254,533 @@ public static void send_external_begin_frame(cef_browser_host_t* self) d(self); } - // ReleaseAcceleratedPaintSurface - private static IntPtr _p2a; - private static release_accelerated_paint_surface_delegate _d2a; - - public static void release_accelerated_paint_surface(cef_browser_host_t* self, ulong surface_id) - { - release_accelerated_paint_surface_delegate d; - var p = self->_release_accelerated_paint_surface; - if (p == _p2a) { d = _d2a; } - else - { - d = (release_accelerated_paint_surface_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(release_accelerated_paint_surface_delegate)); - if (_p2a == IntPtr.Zero) { _d2a = d; _p2a = p; } - } - d(self, surface_id); - } - // SendKeyEvent - private static IntPtr _p2b; - private static send_key_event_delegate _d2b; + private static IntPtr _p2a; + private static send_key_event_delegate _d2a; public static void send_key_event(cef_browser_host_t* self, cef_key_event_t* @event) { send_key_event_delegate d; var p = self->_send_key_event; - if (p == _p2b) { d = _d2b; } + if (p == _p2a) { d = _d2a; } else { d = (send_key_event_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(send_key_event_delegate)); - if (_p2b == IntPtr.Zero) { _d2b = d; _p2b = p; } + if (_p2a == IntPtr.Zero) { _d2a = d; _p2a = p; } } d(self, @event); } // SendMouseClickEvent - private static IntPtr _p2c; - private static send_mouse_click_event_delegate _d2c; + private static IntPtr _p2b; + private static send_mouse_click_event_delegate _d2b; public static void send_mouse_click_event(cef_browser_host_t* self, cef_mouse_event_t* @event, CefMouseButtonType type, int mouseUp, int clickCount) { send_mouse_click_event_delegate d; var p = self->_send_mouse_click_event; - if (p == _p2c) { d = _d2c; } + if (p == _p2b) { d = _d2b; } else { d = (send_mouse_click_event_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(send_mouse_click_event_delegate)); - if (_p2c == IntPtr.Zero) { _d2c = d; _p2c = p; } + if (_p2b == IntPtr.Zero) { _d2b = d; _p2b = p; } } d(self, @event, type, mouseUp, clickCount); } // SendMouseMoveEvent - private static IntPtr _p2d; - private static send_mouse_move_event_delegate _d2d; + private static IntPtr _p2c; + private static send_mouse_move_event_delegate _d2c; public static void send_mouse_move_event(cef_browser_host_t* self, cef_mouse_event_t* @event, int mouseLeave) { send_mouse_move_event_delegate d; var p = self->_send_mouse_move_event; - if (p == _p2d) { d = _d2d; } + if (p == _p2c) { d = _d2c; } else { d = (send_mouse_move_event_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(send_mouse_move_event_delegate)); - if (_p2d == IntPtr.Zero) { _d2d = d; _p2d = p; } + if (_p2c == IntPtr.Zero) { _d2c = d; _p2c = p; } } d(self, @event, mouseLeave); } // SendMouseWheelEvent - private static IntPtr _p2e; - private static send_mouse_wheel_event_delegate _d2e; + private static IntPtr _p2d; + private static send_mouse_wheel_event_delegate _d2d; public static void send_mouse_wheel_event(cef_browser_host_t* self, cef_mouse_event_t* @event, int deltaX, int deltaY) { send_mouse_wheel_event_delegate d; var p = self->_send_mouse_wheel_event; - if (p == _p2e) { d = _d2e; } + if (p == _p2d) { d = _d2d; } else { d = (send_mouse_wheel_event_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(send_mouse_wheel_event_delegate)); - if (_p2e == IntPtr.Zero) { _d2e = d; _p2e = p; } + if (_p2d == IntPtr.Zero) { _d2d = d; _p2d = p; } } d(self, @event, deltaX, deltaY); } // SendTouchEvent - private static IntPtr _p2f; - private static send_touch_event_delegate _d2f; + private static IntPtr _p2e; + private static send_touch_event_delegate _d2e; public static void send_touch_event(cef_browser_host_t* self, cef_touch_event_t* @event) { send_touch_event_delegate d; var p = self->_send_touch_event; - if (p == _p2f) { d = _d2f; } + if (p == _p2e) { d = _d2e; } else { d = (send_touch_event_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(send_touch_event_delegate)); - if (_p2f == IntPtr.Zero) { _d2f = d; _p2f = p; } + if (_p2e == IntPtr.Zero) { _d2e = d; _p2e = p; } } d(self, @event); } // SendCaptureLostEvent - private static IntPtr _p30; - private static send_capture_lost_event_delegate _d30; + private static IntPtr _p2f; + private static send_capture_lost_event_delegate _d2f; public static void send_capture_lost_event(cef_browser_host_t* self) { send_capture_lost_event_delegate d; var p = self->_send_capture_lost_event; - if (p == _p30) { d = _d30; } + if (p == _p2f) { d = _d2f; } else { d = (send_capture_lost_event_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(send_capture_lost_event_delegate)); - if (_p30 == IntPtr.Zero) { _d30 = d; _p30 = p; } + if (_p2f == IntPtr.Zero) { _d2f = d; _p2f = p; } } d(self); } // NotifyMoveOrResizeStarted - private static IntPtr _p31; - private static notify_move_or_resize_started_delegate _d31; + private static IntPtr _p30; + private static notify_move_or_resize_started_delegate _d30; public static void notify_move_or_resize_started(cef_browser_host_t* self) { notify_move_or_resize_started_delegate d; var p = self->_notify_move_or_resize_started; - if (p == _p31) { d = _d31; } + if (p == _p30) { d = _d30; } else { d = (notify_move_or_resize_started_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(notify_move_or_resize_started_delegate)); - if (_p31 == IntPtr.Zero) { _d31 = d; _p31 = p; } + if (_p30 == IntPtr.Zero) { _d30 = d; _p30 = p; } } d(self); } // GetWindowlessFrameRate - private static IntPtr _p32; - private static get_windowless_frame_rate_delegate _d32; + private static IntPtr _p31; + private static get_windowless_frame_rate_delegate _d31; public static int get_windowless_frame_rate(cef_browser_host_t* self) { get_windowless_frame_rate_delegate d; var p = self->_get_windowless_frame_rate; - if (p == _p32) { d = _d32; } + if (p == _p31) { d = _d31; } else { d = (get_windowless_frame_rate_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_windowless_frame_rate_delegate)); - if (_p32 == IntPtr.Zero) { _d32 = d; _p32 = p; } + if (_p31 == IntPtr.Zero) { _d31 = d; _p31 = p; } } return d(self); } // SetWindowlessFrameRate - private static IntPtr _p33; - private static set_windowless_frame_rate_delegate _d33; + private static IntPtr _p32; + private static set_windowless_frame_rate_delegate _d32; public static void set_windowless_frame_rate(cef_browser_host_t* self, int frame_rate) { set_windowless_frame_rate_delegate d; var p = self->_set_windowless_frame_rate; - if (p == _p33) { d = _d33; } + if (p == _p32) { d = _d32; } else { d = (set_windowless_frame_rate_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(set_windowless_frame_rate_delegate)); - if (_p33 == IntPtr.Zero) { _d33 = d; _p33 = p; } + if (_p32 == IntPtr.Zero) { _d32 = d; _p32 = p; } } d(self, frame_rate); } // ImeSetComposition - private static IntPtr _p34; - private static ime_set_composition_delegate _d34; + private static IntPtr _p33; + private static ime_set_composition_delegate _d33; public static void ime_set_composition(cef_browser_host_t* self, cef_string_t* text, UIntPtr underlinesCount, cef_composition_underline_t* underlines, cef_range_t* replacement_range, cef_range_t* selection_range) { ime_set_composition_delegate d; var p = self->_ime_set_composition; - if (p == _p34) { d = _d34; } + if (p == _p33) { d = _d33; } else { d = (ime_set_composition_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(ime_set_composition_delegate)); - if (_p34 == IntPtr.Zero) { _d34 = d; _p34 = p; } + if (_p33 == IntPtr.Zero) { _d33 = d; _p33 = p; } } d(self, text, underlinesCount, underlines, replacement_range, selection_range); } // ImeCommitText - private static IntPtr _p35; - private static ime_commit_text_delegate _d35; + private static IntPtr _p34; + private static ime_commit_text_delegate _d34; public static void ime_commit_text(cef_browser_host_t* self, cef_string_t* text, cef_range_t* replacement_range, int relative_cursor_pos) { ime_commit_text_delegate d; var p = self->_ime_commit_text; - if (p == _p35) { d = _d35; } + if (p == _p34) { d = _d34; } else { d = (ime_commit_text_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(ime_commit_text_delegate)); - if (_p35 == IntPtr.Zero) { _d35 = d; _p35 = p; } + if (_p34 == IntPtr.Zero) { _d34 = d; _p34 = p; } } d(self, text, replacement_range, relative_cursor_pos); } // ImeFinishComposingText - private static IntPtr _p36; - private static ime_finish_composing_text_delegate _d36; + private static IntPtr _p35; + private static ime_finish_composing_text_delegate _d35; public static void ime_finish_composing_text(cef_browser_host_t* self, int keep_selection) { ime_finish_composing_text_delegate d; var p = self->_ime_finish_composing_text; - if (p == _p36) { d = _d36; } + if (p == _p35) { d = _d35; } else { d = (ime_finish_composing_text_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(ime_finish_composing_text_delegate)); - if (_p36 == IntPtr.Zero) { _d36 = d; _p36 = p; } + if (_p35 == IntPtr.Zero) { _d35 = d; _p35 = p; } } d(self, keep_selection); } // ImeCancelComposition - private static IntPtr _p37; - private static ime_cancel_composition_delegate _d37; + private static IntPtr _p36; + private static ime_cancel_composition_delegate _d36; public static void ime_cancel_composition(cef_browser_host_t* self) { ime_cancel_composition_delegate d; var p = self->_ime_cancel_composition; - if (p == _p37) { d = _d37; } + if (p == _p36) { d = _d36; } else { d = (ime_cancel_composition_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(ime_cancel_composition_delegate)); - if (_p37 == IntPtr.Zero) { _d37 = d; _p37 = p; } + if (_p36 == IntPtr.Zero) { _d36 = d; _p36 = p; } } d(self); } // DragTargetDragEnter - private static IntPtr _p38; - private static drag_target_drag_enter_delegate _d38; + private static IntPtr _p37; + private static drag_target_drag_enter_delegate _d37; public static void drag_target_drag_enter(cef_browser_host_t* self, cef_drag_data_t* drag_data, cef_mouse_event_t* @event, CefDragOperationsMask allowed_ops) { drag_target_drag_enter_delegate d; var p = self->_drag_target_drag_enter; - if (p == _p38) { d = _d38; } + if (p == _p37) { d = _d37; } else { d = (drag_target_drag_enter_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(drag_target_drag_enter_delegate)); - if (_p38 == IntPtr.Zero) { _d38 = d; _p38 = p; } + if (_p37 == IntPtr.Zero) { _d37 = d; _p37 = p; } } d(self, drag_data, @event, allowed_ops); } // DragTargetDragOver - private static IntPtr _p39; - private static drag_target_drag_over_delegate _d39; + private static IntPtr _p38; + private static drag_target_drag_over_delegate _d38; public static void drag_target_drag_over(cef_browser_host_t* self, cef_mouse_event_t* @event, CefDragOperationsMask allowed_ops) { drag_target_drag_over_delegate d; var p = self->_drag_target_drag_over; - if (p == _p39) { d = _d39; } + if (p == _p38) { d = _d38; } else { d = (drag_target_drag_over_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(drag_target_drag_over_delegate)); - if (_p39 == IntPtr.Zero) { _d39 = d; _p39 = p; } + if (_p38 == IntPtr.Zero) { _d38 = d; _p38 = p; } } d(self, @event, allowed_ops); } // DragTargetDragLeave - private static IntPtr _p3a; - private static drag_target_drag_leave_delegate _d3a; + private static IntPtr _p39; + private static drag_target_drag_leave_delegate _d39; public static void drag_target_drag_leave(cef_browser_host_t* self) { drag_target_drag_leave_delegate d; var p = self->_drag_target_drag_leave; - if (p == _p3a) { d = _d3a; } + if (p == _p39) { d = _d39; } else { d = (drag_target_drag_leave_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(drag_target_drag_leave_delegate)); - if (_p3a == IntPtr.Zero) { _d3a = d; _p3a = p; } + if (_p39 == IntPtr.Zero) { _d39 = d; _p39 = p; } } d(self); } // DragTargetDrop - private static IntPtr _p3b; - private static drag_target_drop_delegate _d3b; + private static IntPtr _p3a; + private static drag_target_drop_delegate _d3a; public static void drag_target_drop(cef_browser_host_t* self, cef_mouse_event_t* @event) { drag_target_drop_delegate d; var p = self->_drag_target_drop; - if (p == _p3b) { d = _d3b; } + if (p == _p3a) { d = _d3a; } else { d = (drag_target_drop_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(drag_target_drop_delegate)); - if (_p3b == IntPtr.Zero) { _d3b = d; _p3b = p; } + if (_p3a == IntPtr.Zero) { _d3a = d; _p3a = p; } } d(self, @event); } // DragSourceEndedAt - private static IntPtr _p3c; - private static drag_source_ended_at_delegate _d3c; + private static IntPtr _p3b; + private static drag_source_ended_at_delegate _d3b; public static void drag_source_ended_at(cef_browser_host_t* self, int x, int y, CefDragOperationsMask op) { drag_source_ended_at_delegate d; var p = self->_drag_source_ended_at; - if (p == _p3c) { d = _d3c; } + if (p == _p3b) { d = _d3b; } else { d = (drag_source_ended_at_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(drag_source_ended_at_delegate)); - if (_p3c == IntPtr.Zero) { _d3c = d; _p3c = p; } + if (_p3b == IntPtr.Zero) { _d3b = d; _p3b = p; } } d(self, x, y, op); } // DragSourceSystemDragEnded - private static IntPtr _p3d; - private static drag_source_system_drag_ended_delegate _d3d; + private static IntPtr _p3c; + private static drag_source_system_drag_ended_delegate _d3c; public static void drag_source_system_drag_ended(cef_browser_host_t* self) { drag_source_system_drag_ended_delegate d; var p = self->_drag_source_system_drag_ended; - if (p == _p3d) { d = _d3d; } + if (p == _p3c) { d = _d3c; } else { d = (drag_source_system_drag_ended_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(drag_source_system_drag_ended_delegate)); - if (_p3d == IntPtr.Zero) { _d3d = d; _p3d = p; } + if (_p3c == IntPtr.Zero) { _d3c = d; _p3c = p; } } d(self); } // GetVisibleNavigationEntry - private static IntPtr _p3e; - private static get_visible_navigation_entry_delegate _d3e; + private static IntPtr _p3d; + private static get_visible_navigation_entry_delegate _d3d; public static cef_navigation_entry_t* get_visible_navigation_entry(cef_browser_host_t* self) { get_visible_navigation_entry_delegate d; var p = self->_get_visible_navigation_entry; - if (p == _p3e) { d = _d3e; } + if (p == _p3d) { d = _d3d; } else { d = (get_visible_navigation_entry_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_visible_navigation_entry_delegate)); - if (_p3e == IntPtr.Zero) { _d3e = d; _p3e = p; } + if (_p3d == IntPtr.Zero) { _d3d = d; _p3d = p; } } return d(self); } // SetAccessibilityState - private static IntPtr _p3f; - private static set_accessibility_state_delegate _d3f; + private static IntPtr _p3e; + private static set_accessibility_state_delegate _d3e; public static void set_accessibility_state(cef_browser_host_t* self, CefState accessibility_state) { set_accessibility_state_delegate d; var p = self->_set_accessibility_state; - if (p == _p3f) { d = _d3f; } + if (p == _p3e) { d = _d3e; } else { d = (set_accessibility_state_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(set_accessibility_state_delegate)); - if (_p3f == IntPtr.Zero) { _d3f = d; _p3f = p; } + if (_p3e == IntPtr.Zero) { _d3e = d; _p3e = p; } } d(self, accessibility_state); } // SetAutoResizeEnabled - private static IntPtr _p40; - private static set_auto_resize_enabled_delegate _d40; + private static IntPtr _p3f; + private static set_auto_resize_enabled_delegate _d3f; public static void set_auto_resize_enabled(cef_browser_host_t* self, int enabled, cef_size_t* min_size, cef_size_t* max_size) { set_auto_resize_enabled_delegate d; var p = self->_set_auto_resize_enabled; - if (p == _p40) { d = _d40; } + if (p == _p3f) { d = _d3f; } else { d = (set_auto_resize_enabled_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(set_auto_resize_enabled_delegate)); - if (_p40 == IntPtr.Zero) { _d40 = d; _p40 = p; } + if (_p3f == IntPtr.Zero) { _d3f = d; _p3f = p; } } d(self, enabled, min_size, max_size); } // SetAudioMuted - private static IntPtr _p41; - private static set_audio_muted_delegate _d41; + private static IntPtr _p40; + private static set_audio_muted_delegate _d40; public static void set_audio_muted(cef_browser_host_t* self, int mute) { set_audio_muted_delegate d; var p = self->_set_audio_muted; - if (p == _p41) { d = _d41; } + if (p == _p40) { d = _d40; } else { d = (set_audio_muted_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(set_audio_muted_delegate)); - if (_p41 == IntPtr.Zero) { _d41 = d; _p41 = p; } + if (_p40 == IntPtr.Zero) { _d40 = d; _p40 = p; } } d(self, mute); } // IsAudioMuted - private static IntPtr _p42; - private static is_audio_muted_delegate _d42; + private static IntPtr _p41; + private static is_audio_muted_delegate _d41; public static int is_audio_muted(cef_browser_host_t* self) { is_audio_muted_delegate d; var p = self->_is_audio_muted; - if (p == _p42) { d = _d42; } + if (p == _p41) { d = _d41; } else { d = (is_audio_muted_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_audio_muted_delegate)); - if (_p42 == IntPtr.Zero) { _d42 = d; _p42 = p; } + if (_p41 == IntPtr.Zero) { _d41 = d; _p41 = p; } } return d(self); } // IsFullscreen - private static IntPtr _p43; - private static is_fullscreen_delegate _d43; + private static IntPtr _p42; + private static is_fullscreen_delegate _d42; public static int is_fullscreen(cef_browser_host_t* self) { is_fullscreen_delegate d; var p = self->_is_fullscreen; - if (p == _p43) { d = _d43; } + if (p == _p42) { d = _d42; } else { d = (is_fullscreen_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_fullscreen_delegate)); - if (_p43 == IntPtr.Zero) { _d43 = d; _p43 = p; } + if (_p42 == IntPtr.Zero) { _d42 = d; _p42 = p; } } return d(self); } // ExitFullscreen - private static IntPtr _p44; - private static exit_fullscreen_delegate _d44; + private static IntPtr _p43; + private static exit_fullscreen_delegate _d43; public static void exit_fullscreen(cef_browser_host_t* self, int will_cause_resize) { exit_fullscreen_delegate d; var p = self->_exit_fullscreen; - if (p == _p44) { d = _d44; } + if (p == _p43) { d = _d43; } else { d = (exit_fullscreen_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(exit_fullscreen_delegate)); - if (_p44 == IntPtr.Zero) { _d44 = d; _p44 = p; } + if (_p43 == IntPtr.Zero) { _d43 = d; _p43 = p; } } d(self, will_cause_resize); } // CanExecuteChromeCommand - private static IntPtr _p45; - private static can_execute_chrome_command_delegate _d45; + private static IntPtr _p44; + private static can_execute_chrome_command_delegate _d44; public static int can_execute_chrome_command(cef_browser_host_t* self, int command_id) { can_execute_chrome_command_delegate d; var p = self->_can_execute_chrome_command; - if (p == _p45) { d = _d45; } + if (p == _p44) { d = _d44; } else { d = (can_execute_chrome_command_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(can_execute_chrome_command_delegate)); - if (_p45 == IntPtr.Zero) { _d45 = d; _p45 = p; } + if (_p44 == IntPtr.Zero) { _d44 = d; _p44 = p; } } return d(self, command_id); } // ExecuteChromeCommand - private static IntPtr _p46; - private static execute_chrome_command_delegate _d46; + private static IntPtr _p45; + private static execute_chrome_command_delegate _d45; public static void execute_chrome_command(cef_browser_host_t* self, int command_id, CefWindowOpenDisposition disposition) { execute_chrome_command_delegate d; var p = self->_execute_chrome_command; - if (p == _p46) { d = _d46; } + if (p == _p45) { d = _d45; } else { d = (execute_chrome_command_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(execute_chrome_command_delegate)); - if (_p46 == IntPtr.Zero) { _d46 = d; _p46 = p; } + if (_p45 == IntPtr.Zero) { _d45 = d; _p45 = p; } } d(self, command_id, disposition); } // IsRenderProcessUnresponsive - private static IntPtr _p47; - private static is_render_process_unresponsive_delegate _d47; + private static IntPtr _p46; + private static is_render_process_unresponsive_delegate _d46; public static int is_render_process_unresponsive(cef_browser_host_t* self) { is_render_process_unresponsive_delegate d; var p = self->_is_render_process_unresponsive; - if (p == _p47) { d = _d47; } + if (p == _p46) { d = _d46; } else { d = (is_render_process_unresponsive_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_render_process_unresponsive_delegate)); - if (_p47 == IntPtr.Zero) { _d47 = d; _p47 = p; } + if (_p46 == IntPtr.Zero) { _d46 = d; _p46 = p; } } return d(self); } // GetRuntimeStyle - private static IntPtr _p48; - private static get_runtime_style_delegate _d48; + private static IntPtr _p47; + private static get_runtime_style_delegate _d47; public static CefRuntimeStyle get_runtime_style(cef_browser_host_t* self) { get_runtime_style_delegate d; var p = self->_get_runtime_style; - if (p == _p48) { d = _d48; } + if (p == _p47) { d = _d47; } else { d = (get_runtime_style_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_runtime_style_delegate)); - if (_p48 == IntPtr.Zero) { _d48 = d; _p48 = p; } + if (_p47 == IntPtr.Zero) { _d47 = d; _p47 = p; } } return d(self); } + // ReleaseAcceleratedPaintSurface + private static IntPtr _p48; + private static release_accelerated_paint_surface_delegate _d48; + + public static void release_accelerated_paint_surface(cef_browser_host_t* self, ulong surface_id) + { + release_accelerated_paint_surface_delegate d; + var p = self->_release_accelerated_paint_surface; + if (p == _p48) { d = _d48; } + else + { + d = (release_accelerated_paint_surface_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(release_accelerated_paint_surface_delegate)); + if (_p48 == IntPtr.Zero) { _d48 = d; _p48 = p; } + } + d(self, surface_id); + } + // SetAxViewportCollapse private static IntPtr _p49; private static set_ax_viewport_collapse_delegate _d49; diff --git a/CefGlue/Interop/Classes.g/cef_command_line_t.g.cs b/CefGlue/Interop/Classes.g/cef_command_line_t.g.cs index a75904e..9c827ff 100644 --- a/CefGlue/Interop/Classes.g/cef_command_line_t.g.cs +++ b/CefGlue/Interop/Classes.g/cef_command_line_t.g.cs @@ -29,11 +29,11 @@ internal unsafe struct cef_command_line_t internal IntPtr _get_switches; internal IntPtr _append_switch; internal IntPtr _append_switch_with_value; - internal IntPtr _remove_switch; internal IntPtr _has_arguments; internal IntPtr _get_arguments; internal IntPtr _append_argument; internal IntPtr _prepend_wrapper; + internal IntPtr _remove_switch; // CreateCommandLine [DllImport(libcef.DllName, EntryPoint = "cef_command_line_create", CallingConvention = libcef.CEF_CALL)] @@ -167,31 +167,31 @@ internal unsafe struct cef_command_line_t #if !DEBUG [SuppressUnmanagedCodeSecurity] #endif - private delegate void remove_switch_delegate(cef_command_line_t* self, cef_string_t* name); + private delegate int has_arguments_delegate(cef_command_line_t* self); [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)] #if !DEBUG [SuppressUnmanagedCodeSecurity] #endif - private delegate int has_arguments_delegate(cef_command_line_t* self); + private delegate void get_arguments_delegate(cef_command_line_t* self, cef_string_list* arguments); [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)] #if !DEBUG [SuppressUnmanagedCodeSecurity] #endif - private delegate void get_arguments_delegate(cef_command_line_t* self, cef_string_list* arguments); + private delegate void append_argument_delegate(cef_command_line_t* self, cef_string_t* argument); [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)] #if !DEBUG [SuppressUnmanagedCodeSecurity] #endif - private delegate void append_argument_delegate(cef_command_line_t* self, cef_string_t* argument); + private delegate void prepend_wrapper_delegate(cef_command_line_t* self, cef_string_t* wrapper); [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)] #if !DEBUG [SuppressUnmanagedCodeSecurity] #endif - private delegate void prepend_wrapper_delegate(cef_command_line_t* self, cef_string_t* wrapper); + private delegate void remove_switch_delegate(cef_command_line_t* self, cef_string_t* name); // AddRef private static IntPtr _p0; @@ -533,90 +533,90 @@ public static void append_switch_with_value(cef_command_line_t* self, cef_string d(self, name, value); } - // RemoveSwitch - private static IntPtr _p14; - private static remove_switch_delegate _d14; - - public static void remove_switch(cef_command_line_t* self, cef_string_t* name) - { - remove_switch_delegate d; - var p = self->_remove_switch; - if (p == _p14) { d = _d14; } - else - { - d = (remove_switch_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(remove_switch_delegate)); - if (_p14 == IntPtr.Zero) { _d14 = d; _p14 = p; } - } - d(self, name); - } - // HasArguments - private static IntPtr _p15; - private static has_arguments_delegate _d15; + private static IntPtr _p14; + private static has_arguments_delegate _d14; public static int has_arguments(cef_command_line_t* self) { has_arguments_delegate d; var p = self->_has_arguments; - if (p == _p15) { d = _d15; } + if (p == _p14) { d = _d14; } else { d = (has_arguments_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(has_arguments_delegate)); - if (_p15 == IntPtr.Zero) { _d15 = d; _p15 = p; } + if (_p14 == IntPtr.Zero) { _d14 = d; _p14 = p; } } return d(self); } // GetArguments - private static IntPtr _p16; - private static get_arguments_delegate _d16; + private static IntPtr _p15; + private static get_arguments_delegate _d15; public static void get_arguments(cef_command_line_t* self, cef_string_list* arguments) { get_arguments_delegate d; var p = self->_get_arguments; - if (p == _p16) { d = _d16; } + if (p == _p15) { d = _d15; } else { d = (get_arguments_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_arguments_delegate)); - if (_p16 == IntPtr.Zero) { _d16 = d; _p16 = p; } + if (_p15 == IntPtr.Zero) { _d15 = d; _p15 = p; } } d(self, arguments); } // AppendArgument - private static IntPtr _p17; - private static append_argument_delegate _d17; + private static IntPtr _p16; + private static append_argument_delegate _d16; public static void append_argument(cef_command_line_t* self, cef_string_t* argument) { append_argument_delegate d; var p = self->_append_argument; - if (p == _p17) { d = _d17; } + if (p == _p16) { d = _d16; } else { d = (append_argument_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(append_argument_delegate)); - if (_p17 == IntPtr.Zero) { _d17 = d; _p17 = p; } + if (_p16 == IntPtr.Zero) { _d16 = d; _p16 = p; } } d(self, argument); } // PrependWrapper - private static IntPtr _p18; - private static prepend_wrapper_delegate _d18; + private static IntPtr _p17; + private static prepend_wrapper_delegate _d17; public static void prepend_wrapper(cef_command_line_t* self, cef_string_t* wrapper) { prepend_wrapper_delegate d; var p = self->_prepend_wrapper; - if (p == _p18) { d = _d18; } + if (p == _p17) { d = _d17; } else { d = (prepend_wrapper_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(prepend_wrapper_delegate)); - if (_p18 == IntPtr.Zero) { _d18 = d; _p18 = p; } + if (_p17 == IntPtr.Zero) { _d17 = d; _p17 = p; } } d(self, wrapper); } + // RemoveSwitch + private static IntPtr _p18; + private static remove_switch_delegate _d18; + + public static void remove_switch(cef_command_line_t* self, cef_string_t* name) + { + remove_switch_delegate d; + var p = self->_remove_switch; + if (p == _p18) { d = _d18; } + else + { + d = (remove_switch_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(remove_switch_delegate)); + if (_p18 == IntPtr.Zero) { _d18 = d; _p18 = p; } + } + d(self, name); + } + } } diff --git a/CefGlue/Interop/Classes.g/cef_download_item_t.g.cs b/CefGlue/Interop/Classes.g/cef_download_item_t.g.cs index 5d7a468..b7bf124 100644 --- a/CefGlue/Interop/Classes.g/cef_download_item_t.g.cs +++ b/CefGlue/Interop/Classes.g/cef_download_item_t.g.cs @@ -18,7 +18,6 @@ internal unsafe struct cef_download_item_t internal IntPtr _is_complete; internal IntPtr _is_canceled; internal IntPtr _is_interrupted; - internal IntPtr _is_paused; internal IntPtr _get_interrupt_reason; internal IntPtr _get_current_speed; internal IntPtr _get_percent_complete; @@ -33,6 +32,7 @@ internal unsafe struct cef_download_item_t internal IntPtr _get_suggested_file_name; internal IntPtr _get_content_disposition; internal IntPtr _get_mime_type; + internal IntPtr _is_paused; [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)] #if !DEBUG @@ -88,12 +88,6 @@ internal unsafe struct cef_download_item_t #endif private delegate int is_interrupted_delegate(cef_download_item_t* self); - [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)] - #if !DEBUG - [SuppressUnmanagedCodeSecurity] - #endif - private delegate int is_paused_delegate(cef_download_item_t* self); - [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)] #if !DEBUG [SuppressUnmanagedCodeSecurity] @@ -178,6 +172,12 @@ internal unsafe struct cef_download_item_t #endif private delegate cef_string_userfree* get_mime_type_delegate(cef_download_item_t* self); + [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)] + #if !DEBUG + [SuppressUnmanagedCodeSecurity] + #endif + private delegate int is_paused_delegate(cef_download_item_t* self); + // AddRef private static IntPtr _p0; private static add_ref_delegate _d0; @@ -331,256 +331,256 @@ public static int is_interrupted(cef_download_item_t* self) return d(self); } - // IsPaused - private static IntPtr _p9; - private static is_paused_delegate _d9; - - public static int is_paused(cef_download_item_t* self) - { - is_paused_delegate d; - var p = self->_is_paused; - if (p == _p9) { d = _d9; } - else - { - d = (is_paused_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_paused_delegate)); - if (_p9 == IntPtr.Zero) { _d9 = d; _p9 = p; } - } - return d(self); - } - // GetInterruptReason - private static IntPtr _pa; - private static get_interrupt_reason_delegate _da; + private static IntPtr _p9; + private static get_interrupt_reason_delegate _d9; public static CefDownloadInterruptReason get_interrupt_reason(cef_download_item_t* self) { get_interrupt_reason_delegate d; var p = self->_get_interrupt_reason; - if (p == _pa) { d = _da; } + if (p == _p9) { d = _d9; } else { d = (get_interrupt_reason_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_interrupt_reason_delegate)); - if (_pa == IntPtr.Zero) { _da = d; _pa = p; } + if (_p9 == IntPtr.Zero) { _d9 = d; _p9 = p; } } return d(self); } // GetCurrentSpeed - private static IntPtr _pb; - private static get_current_speed_delegate _db; + private static IntPtr _pa; + private static get_current_speed_delegate _da; public static long get_current_speed(cef_download_item_t* self) { get_current_speed_delegate d; var p = self->_get_current_speed; - if (p == _pb) { d = _db; } + if (p == _pa) { d = _da; } else { d = (get_current_speed_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_current_speed_delegate)); - if (_pb == IntPtr.Zero) { _db = d; _pb = p; } + if (_pa == IntPtr.Zero) { _da = d; _pa = p; } } return d(self); } // GetPercentComplete - private static IntPtr _pc; - private static get_percent_complete_delegate _dc; + private static IntPtr _pb; + private static get_percent_complete_delegate _db; public static int get_percent_complete(cef_download_item_t* self) { get_percent_complete_delegate d; var p = self->_get_percent_complete; - if (p == _pc) { d = _dc; } + if (p == _pb) { d = _db; } else { d = (get_percent_complete_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_percent_complete_delegate)); - if (_pc == IntPtr.Zero) { _dc = d; _pc = p; } + if (_pb == IntPtr.Zero) { _db = d; _pb = p; } } return d(self); } // GetTotalBytes - private static IntPtr _pd; - private static get_total_bytes_delegate _dd; + private static IntPtr _pc; + private static get_total_bytes_delegate _dc; public static long get_total_bytes(cef_download_item_t* self) { get_total_bytes_delegate d; var p = self->_get_total_bytes; - if (p == _pd) { d = _dd; } + if (p == _pc) { d = _dc; } else { d = (get_total_bytes_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_total_bytes_delegate)); - if (_pd == IntPtr.Zero) { _dd = d; _pd = p; } + if (_pc == IntPtr.Zero) { _dc = d; _pc = p; } } return d(self); } // GetReceivedBytes - private static IntPtr _pe; - private static get_received_bytes_delegate _de; + private static IntPtr _pd; + private static get_received_bytes_delegate _dd; public static long get_received_bytes(cef_download_item_t* self) { get_received_bytes_delegate d; var p = self->_get_received_bytes; - if (p == _pe) { d = _de; } + if (p == _pd) { d = _dd; } else { d = (get_received_bytes_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_received_bytes_delegate)); - if (_pe == IntPtr.Zero) { _de = d; _pe = p; } + if (_pd == IntPtr.Zero) { _dd = d; _pd = p; } } return d(self); } // GetStartTime - private static IntPtr _pf; - private static get_start_time_delegate _df; + private static IntPtr _pe; + private static get_start_time_delegate _de; public static CefBaseTime get_start_time(cef_download_item_t* self) { get_start_time_delegate d; var p = self->_get_start_time; - if (p == _pf) { d = _df; } + if (p == _pe) { d = _de; } else { d = (get_start_time_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_start_time_delegate)); - if (_pf == IntPtr.Zero) { _df = d; _pf = p; } + if (_pe == IntPtr.Zero) { _de = d; _pe = p; } } return d(self); } // GetEndTime - private static IntPtr _p10; - private static get_end_time_delegate _d10; + private static IntPtr _pf; + private static get_end_time_delegate _df; public static CefBaseTime get_end_time(cef_download_item_t* self) { get_end_time_delegate d; var p = self->_get_end_time; - if (p == _p10) { d = _d10; } + if (p == _pf) { d = _df; } else { d = (get_end_time_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_end_time_delegate)); - if (_p10 == IntPtr.Zero) { _d10 = d; _p10 = p; } + if (_pf == IntPtr.Zero) { _df = d; _pf = p; } } return d(self); } // GetFullPath - private static IntPtr _p11; - private static get_full_path_delegate _d11; + private static IntPtr _p10; + private static get_full_path_delegate _d10; public static cef_string_userfree* get_full_path(cef_download_item_t* self) { get_full_path_delegate d; var p = self->_get_full_path; - if (p == _p11) { d = _d11; } + if (p == _p10) { d = _d10; } else { d = (get_full_path_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_full_path_delegate)); - if (_p11 == IntPtr.Zero) { _d11 = d; _p11 = p; } + if (_p10 == IntPtr.Zero) { _d10 = d; _p10 = p; } } return d(self); } // GetId - private static IntPtr _p12; - private static get_id_delegate _d12; + private static IntPtr _p11; + private static get_id_delegate _d11; public static uint get_id(cef_download_item_t* self) { get_id_delegate d; var p = self->_get_id; - if (p == _p12) { d = _d12; } + if (p == _p11) { d = _d11; } else { d = (get_id_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_id_delegate)); - if (_p12 == IntPtr.Zero) { _d12 = d; _p12 = p; } + if (_p11 == IntPtr.Zero) { _d11 = d; _p11 = p; } } return d(self); } // GetURL - private static IntPtr _p13; - private static get_url_delegate _d13; + private static IntPtr _p12; + private static get_url_delegate _d12; public static cef_string_userfree* get_url(cef_download_item_t* self) { get_url_delegate d; var p = self->_get_url; - if (p == _p13) { d = _d13; } + if (p == _p12) { d = _d12; } else { d = (get_url_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_url_delegate)); - if (_p13 == IntPtr.Zero) { _d13 = d; _p13 = p; } + if (_p12 == IntPtr.Zero) { _d12 = d; _p12 = p; } } return d(self); } // GetOriginalUrl - private static IntPtr _p14; - private static get_original_url_delegate _d14; + private static IntPtr _p13; + private static get_original_url_delegate _d13; public static cef_string_userfree* get_original_url(cef_download_item_t* self) { get_original_url_delegate d; var p = self->_get_original_url; - if (p == _p14) { d = _d14; } + if (p == _p13) { d = _d13; } else { d = (get_original_url_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_original_url_delegate)); - if (_p14 == IntPtr.Zero) { _d14 = d; _p14 = p; } + if (_p13 == IntPtr.Zero) { _d13 = d; _p13 = p; } } return d(self); } // GetSuggestedFileName - private static IntPtr _p15; - private static get_suggested_file_name_delegate _d15; + private static IntPtr _p14; + private static get_suggested_file_name_delegate _d14; public static cef_string_userfree* get_suggested_file_name(cef_download_item_t* self) { get_suggested_file_name_delegate d; var p = self->_get_suggested_file_name; - if (p == _p15) { d = _d15; } + if (p == _p14) { d = _d14; } else { d = (get_suggested_file_name_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_suggested_file_name_delegate)); - if (_p15 == IntPtr.Zero) { _d15 = d; _p15 = p; } + if (_p14 == IntPtr.Zero) { _d14 = d; _p14 = p; } } return d(self); } // GetContentDisposition - private static IntPtr _p16; - private static get_content_disposition_delegate _d16; + private static IntPtr _p15; + private static get_content_disposition_delegate _d15; public static cef_string_userfree* get_content_disposition(cef_download_item_t* self) { get_content_disposition_delegate d; var p = self->_get_content_disposition; - if (p == _p16) { d = _d16; } + if (p == _p15) { d = _d15; } else { d = (get_content_disposition_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_content_disposition_delegate)); - if (_p16 == IntPtr.Zero) { _d16 = d; _p16 = p; } + if (_p15 == IntPtr.Zero) { _d15 = d; _p15 = p; } } return d(self); } // GetMimeType - private static IntPtr _p17; - private static get_mime_type_delegate _d17; + private static IntPtr _p16; + private static get_mime_type_delegate _d16; public static cef_string_userfree* get_mime_type(cef_download_item_t* self) { get_mime_type_delegate d; var p = self->_get_mime_type; - if (p == _p17) { d = _d17; } + if (p == _p16) { d = _d16; } else { d = (get_mime_type_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_mime_type_delegate)); + if (_p16 == IntPtr.Zero) { _d16 = d; _p16 = p; } + } + return d(self); + } + + // IsPaused + private static IntPtr _p17; + private static is_paused_delegate _d17; + + public static int is_paused(cef_download_item_t* self) + { + is_paused_delegate d; + var p = self->_is_paused; + if (p == _p17) { d = _d17; } + else + { + d = (is_paused_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_paused_delegate)); if (_p17 == IntPtr.Zero) { _d17 = d; _p17 = p; } } return d(self); diff --git a/CefGlue/Interop/Classes.g/cef_request_context_t.g.cs b/CefGlue/Interop/Classes.g/cef_request_context_t.g.cs index 9b11ee3..16451e9 100644 --- a/CefGlue/Interop/Classes.g/cef_request_context_t.g.cs +++ b/CefGlue/Interop/Classes.g/cef_request_context_t.g.cs @@ -28,7 +28,6 @@ internal unsafe struct cef_request_context_t internal IntPtr _register_scheme_handler_factory; internal IntPtr _clear_scheme_handler_factories; internal IntPtr _clear_certificate_exceptions; - internal IntPtr _clear_http_cache; internal IntPtr _clear_http_auth_credentials; internal IntPtr _close_all_connections; internal IntPtr _resolve_host; @@ -37,11 +36,12 @@ internal unsafe struct cef_request_context_t internal IntPtr _set_website_setting; internal IntPtr _get_content_setting; internal IntPtr _set_content_setting; - internal IntPtr _add_setting_observer; internal IntPtr _set_chrome_color_scheme; internal IntPtr _get_chrome_color_scheme_mode; internal IntPtr _get_chrome_color_scheme_color; internal IntPtr _get_chrome_color_scheme_variant; + internal IntPtr _add_setting_observer; + internal IntPtr _clear_http_cache; // GetGlobalContext [DllImport(libcef.DllName, EntryPoint = "cef_request_context_get_global_context", CallingConvention = libcef.CEF_CALL)] @@ -169,12 +169,6 @@ internal unsafe struct cef_request_context_t #endif private delegate void clear_certificate_exceptions_delegate(cef_request_context_t* self, cef_completion_callback_t* callback); - [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)] - #if !DEBUG - [SuppressUnmanagedCodeSecurity] - #endif - private delegate void clear_http_cache_delegate(cef_request_context_t* self, cef_completion_callback_t* callback); - [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)] #if !DEBUG [SuppressUnmanagedCodeSecurity] @@ -227,31 +221,37 @@ internal unsafe struct cef_request_context_t #if !DEBUG [SuppressUnmanagedCodeSecurity] #endif - private delegate cef_registration_t* add_setting_observer_delegate(cef_request_context_t* self, cef_setting_observer_t* observer); + private delegate void set_chrome_color_scheme_delegate(cef_request_context_t* self, CefColorVariant variant, uint user_color); [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)] #if !DEBUG [SuppressUnmanagedCodeSecurity] #endif - private delegate void set_chrome_color_scheme_delegate(cef_request_context_t* self, CefColorVariant variant, uint user_color); + private delegate CefColorVariant get_chrome_color_scheme_mode_delegate(cef_request_context_t* self); [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)] #if !DEBUG [SuppressUnmanagedCodeSecurity] #endif - private delegate CefColorVariant get_chrome_color_scheme_mode_delegate(cef_request_context_t* self); + private delegate uint get_chrome_color_scheme_color_delegate(cef_request_context_t* self); [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)] #if !DEBUG [SuppressUnmanagedCodeSecurity] #endif - private delegate uint get_chrome_color_scheme_color_delegate(cef_request_context_t* self); + private delegate CefColorVariant get_chrome_color_scheme_variant_delegate(cef_request_context_t* self); [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)] #if !DEBUG [SuppressUnmanagedCodeSecurity] #endif - private delegate CefColorVariant get_chrome_color_scheme_variant_delegate(cef_request_context_t* self); + private delegate cef_registration_t* add_setting_observer_delegate(cef_request_context_t* self, cef_setting_observer_t* observer); + + [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)] + #if !DEBUG + [SuppressUnmanagedCodeSecurity] + #endif + private delegate void clear_http_cache_delegate(cef_request_context_t* self, cef_completion_callback_t* callback); // AddRef private static IntPtr _p0; @@ -576,243 +576,243 @@ public static void clear_certificate_exceptions(cef_request_context_t* self, cef d(self, callback); } - // ClearHttpCache - private static IntPtr _p13; - private static clear_http_cache_delegate _d13; - - public static void clear_http_cache(cef_request_context_t* self, cef_completion_callback_t* callback) - { - clear_http_cache_delegate d; - var p = self->_clear_http_cache; - if (p == _p13) { d = _d13; } - else - { - d = (clear_http_cache_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(clear_http_cache_delegate)); - if (_p13 == IntPtr.Zero) { _d13 = d; _p13 = p; } - } - d(self, callback); - } - // ClearHttpAuthCredentials - private static IntPtr _p14; - private static clear_http_auth_credentials_delegate _d14; + private static IntPtr _p13; + private static clear_http_auth_credentials_delegate _d13; public static void clear_http_auth_credentials(cef_request_context_t* self, cef_completion_callback_t* callback) { clear_http_auth_credentials_delegate d; var p = self->_clear_http_auth_credentials; - if (p == _p14) { d = _d14; } + if (p == _p13) { d = _d13; } else { d = (clear_http_auth_credentials_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(clear_http_auth_credentials_delegate)); - if (_p14 == IntPtr.Zero) { _d14 = d; _p14 = p; } + if (_p13 == IntPtr.Zero) { _d13 = d; _p13 = p; } } d(self, callback); } // CloseAllConnections - private static IntPtr _p15; - private static close_all_connections_delegate _d15; + private static IntPtr _p14; + private static close_all_connections_delegate _d14; public static void close_all_connections(cef_request_context_t* self, cef_completion_callback_t* callback) { close_all_connections_delegate d; var p = self->_close_all_connections; - if (p == _p15) { d = _d15; } + if (p == _p14) { d = _d14; } else { d = (close_all_connections_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(close_all_connections_delegate)); - if (_p15 == IntPtr.Zero) { _d15 = d; _p15 = p; } + if (_p14 == IntPtr.Zero) { _d14 = d; _p14 = p; } } d(self, callback); } // ResolveHost - private static IntPtr _p16; - private static resolve_host_delegate _d16; + private static IntPtr _p15; + private static resolve_host_delegate _d15; public static void resolve_host(cef_request_context_t* self, cef_string_t* origin, cef_resolve_callback_t* callback) { resolve_host_delegate d; var p = self->_resolve_host; - if (p == _p16) { d = _d16; } + if (p == _p15) { d = _d15; } else { d = (resolve_host_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(resolve_host_delegate)); - if (_p16 == IntPtr.Zero) { _d16 = d; _p16 = p; } + if (_p15 == IntPtr.Zero) { _d15 = d; _p15 = p; } } d(self, origin, callback); } // GetMediaRouter - private static IntPtr _p17; - private static get_media_router_delegate _d17; + private static IntPtr _p16; + private static get_media_router_delegate _d16; public static cef_media_router_t* get_media_router(cef_request_context_t* self, cef_completion_callback_t* callback) { get_media_router_delegate d; var p = self->_get_media_router; - if (p == _p17) { d = _d17; } + if (p == _p16) { d = _d16; } else { d = (get_media_router_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_media_router_delegate)); - if (_p17 == IntPtr.Zero) { _d17 = d; _p17 = p; } + if (_p16 == IntPtr.Zero) { _d16 = d; _p16 = p; } } return d(self, callback); } // GetWebsiteSetting - private static IntPtr _p18; - private static get_website_setting_delegate _d18; + private static IntPtr _p17; + private static get_website_setting_delegate _d17; public static cef_value_t* get_website_setting(cef_request_context_t* self, cef_string_t* requesting_url, cef_string_t* top_level_url, CefContentSettingType content_type) { get_website_setting_delegate d; var p = self->_get_website_setting; - if (p == _p18) { d = _d18; } + if (p == _p17) { d = _d17; } else { d = (get_website_setting_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_website_setting_delegate)); - if (_p18 == IntPtr.Zero) { _d18 = d; _p18 = p; } + if (_p17 == IntPtr.Zero) { _d17 = d; _p17 = p; } } return d(self, requesting_url, top_level_url, content_type); } // SetWebsiteSetting - private static IntPtr _p19; - private static set_website_setting_delegate _d19; + private static IntPtr _p18; + private static set_website_setting_delegate _d18; public static void set_website_setting(cef_request_context_t* self, cef_string_t* requesting_url, cef_string_t* top_level_url, CefContentSettingType content_type, cef_value_t* value) { set_website_setting_delegate d; var p = self->_set_website_setting; - if (p == _p19) { d = _d19; } + if (p == _p18) { d = _d18; } else { d = (set_website_setting_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(set_website_setting_delegate)); - if (_p19 == IntPtr.Zero) { _d19 = d; _p19 = p; } + if (_p18 == IntPtr.Zero) { _d18 = d; _p18 = p; } } d(self, requesting_url, top_level_url, content_type, value); } // GetContentSetting - private static IntPtr _p1a; - private static get_content_setting_delegate _d1a; + private static IntPtr _p19; + private static get_content_setting_delegate _d19; public static CefContentSettingValue get_content_setting(cef_request_context_t* self, cef_string_t* requesting_url, cef_string_t* top_level_url, CefContentSettingType content_type) { get_content_setting_delegate d; var p = self->_get_content_setting; - if (p == _p1a) { d = _d1a; } + if (p == _p19) { d = _d19; } else { d = (get_content_setting_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_content_setting_delegate)); - if (_p1a == IntPtr.Zero) { _d1a = d; _p1a = p; } + if (_p19 == IntPtr.Zero) { _d19 = d; _p19 = p; } } return d(self, requesting_url, top_level_url, content_type); } // SetContentSetting - private static IntPtr _p1b; - private static set_content_setting_delegate _d1b; + private static IntPtr _p1a; + private static set_content_setting_delegate _d1a; public static void set_content_setting(cef_request_context_t* self, cef_string_t* requesting_url, cef_string_t* top_level_url, CefContentSettingType content_type, CefContentSettingValue value) { set_content_setting_delegate d; var p = self->_set_content_setting; - if (p == _p1b) { d = _d1b; } + if (p == _p1a) { d = _d1a; } else { d = (set_content_setting_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(set_content_setting_delegate)); - if (_p1b == IntPtr.Zero) { _d1b = d; _p1b = p; } + if (_p1a == IntPtr.Zero) { _d1a = d; _p1a = p; } } d(self, requesting_url, top_level_url, content_type, value); } - // AddSettingObserver - private static IntPtr _p1c; - private static add_setting_observer_delegate _d1c; - - public static cef_registration_t* add_setting_observer(cef_request_context_t* self, cef_setting_observer_t* observer) - { - add_setting_observer_delegate d; - var p = self->_add_setting_observer; - if (p == _p1c) { d = _d1c; } - else - { - d = (add_setting_observer_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(add_setting_observer_delegate)); - if (_p1c == IntPtr.Zero) { _d1c = d; _p1c = p; } - } - return d(self, observer); - } - // SetChromeColorScheme - private static IntPtr _p1d; - private static set_chrome_color_scheme_delegate _d1d; + private static IntPtr _p1b; + private static set_chrome_color_scheme_delegate _d1b; public static void set_chrome_color_scheme(cef_request_context_t* self, CefColorVariant variant, uint user_color) { set_chrome_color_scheme_delegate d; var p = self->_set_chrome_color_scheme; - if (p == _p1d) { d = _d1d; } + if (p == _p1b) { d = _d1b; } else { d = (set_chrome_color_scheme_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(set_chrome_color_scheme_delegate)); - if (_p1d == IntPtr.Zero) { _d1d = d; _p1d = p; } + if (_p1b == IntPtr.Zero) { _d1b = d; _p1b = p; } } d(self, variant, user_color); } // GetChromeColorSchemeMode - private static IntPtr _p1e; - private static get_chrome_color_scheme_mode_delegate _d1e; + private static IntPtr _p1c; + private static get_chrome_color_scheme_mode_delegate _d1c; public static CefColorVariant get_chrome_color_scheme_mode(cef_request_context_t* self) { get_chrome_color_scheme_mode_delegate d; var p = self->_get_chrome_color_scheme_mode; - if (p == _p1e) { d = _d1e; } + if (p == _p1c) { d = _d1c; } else { d = (get_chrome_color_scheme_mode_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_chrome_color_scheme_mode_delegate)); - if (_p1e == IntPtr.Zero) { _d1e = d; _p1e = p; } + if (_p1c == IntPtr.Zero) { _d1c = d; _p1c = p; } } return d(self); } // GetChromeColorSchemeColor - private static IntPtr _p1f; - private static get_chrome_color_scheme_color_delegate _d1f; + private static IntPtr _p1d; + private static get_chrome_color_scheme_color_delegate _d1d; public static uint get_chrome_color_scheme_color(cef_request_context_t* self) { get_chrome_color_scheme_color_delegate d; var p = self->_get_chrome_color_scheme_color; - if (p == _p1f) { d = _d1f; } + if (p == _p1d) { d = _d1d; } else { d = (get_chrome_color_scheme_color_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_chrome_color_scheme_color_delegate)); - if (_p1f == IntPtr.Zero) { _d1f = d; _p1f = p; } + if (_p1d == IntPtr.Zero) { _d1d = d; _p1d = p; } } return d(self); } // GetChromeColorSchemeVariant - private static IntPtr _p20; - private static get_chrome_color_scheme_variant_delegate _d20; + private static IntPtr _p1e; + private static get_chrome_color_scheme_variant_delegate _d1e; public static CefColorVariant get_chrome_color_scheme_variant(cef_request_context_t* self) { get_chrome_color_scheme_variant_delegate d; var p = self->_get_chrome_color_scheme_variant; - if (p == _p20) { d = _d20; } + if (p == _p1e) { d = _d1e; } else { d = (get_chrome_color_scheme_variant_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_chrome_color_scheme_variant_delegate)); - if (_p20 == IntPtr.Zero) { _d20 = d; _p20 = p; } + if (_p1e == IntPtr.Zero) { _d1e = d; _p1e = p; } } return d(self); } + // AddSettingObserver + private static IntPtr _p1f; + private static add_setting_observer_delegate _d1f; + + public static cef_registration_t* add_setting_observer(cef_request_context_t* self, cef_setting_observer_t* observer) + { + add_setting_observer_delegate d; + var p = self->_add_setting_observer; + if (p == _p1f) { d = _d1f; } + else + { + d = (add_setting_observer_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(add_setting_observer_delegate)); + if (_p1f == IntPtr.Zero) { _d1f = d; _p1f = p; } + } + return d(self, observer); + } + + // ClearHttpCache + private static IntPtr _p20; + private static clear_http_cache_delegate _d20; + + public static void clear_http_cache(cef_request_context_t* self, cef_completion_callback_t* callback) + { + clear_http_cache_delegate d; + var p = self->_clear_http_cache; + if (p == _p20) { d = _d20; } + else + { + d = (clear_http_cache_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(clear_http_cache_delegate)); + if (_p20 == IntPtr.Zero) { _d20 = d; _p20 = p; } + } + d(self, callback); + } + } } diff --git a/CefGlue/Interop/version.g.cs b/CefGlue/Interop/version.g.cs index 0acc88d..d1b240e 100644 --- a/CefGlue/Interop/version.g.cs +++ b/CefGlue/Interop/version.g.cs @@ -9,19 +9,19 @@ namespace Xilium.CefGlue.Interop internal static unsafe partial class libcef { - public const string CEF_VERSION = "150.0.17+g94c1726+chromium-150.0.7871.187"; + public const string CEF_VERSION = "150.0.23-2026-08-04-surface-lease.3556+ge7ab2e1+chromium-150.0.7871.187"; public const int CEF_VERSION_MAJOR = 150; - public const int CEF_COMMIT_NUMBER = 3550; - public const string CEF_COMMIT_HASH = "94c17267eb4595a1ad17fb67dee6cdb8ded41c6d"; + public const int CEF_COMMIT_NUMBER = 3556; + public const string CEF_COMMIT_HASH = "e7ab2e15e1973d318458b5882a448be97ebd08c7"; public const int CHROME_VERSION_MAJOR = 150; public const int CHROME_VERSION_MINOR = 0; public const int CHROME_VERSION_BUILD = 7871; public const int CHROME_VERSION_PATCH = 187; - public const int CEF_API_VERSION = 15000; - public const string CEF_API_HASH_PLATFORM_WIN = "71146b4350a01d3805e7ea990eb034e6ef4d53db"; - public const string CEF_API_HASH_PLATFORM_MACOS = "e85c868aa8a947e1e7c9904c0745c60ae490fa05"; - public const string CEF_API_HASH_PLATFORM_LINUX = "210767725a6feb2e4becd3956b648cab6a006712"; + public const int CEF_API_VERSION = 999999; + public const string CEF_API_HASH_PLATFORM_WIN = "98f8c0d3b73ee1ade0ea70e5e67f48116fa2b3f3"; + public const string CEF_API_HASH_PLATFORM_MACOS = "f7f0a19b29e2f1cb7dec42ee3ef26fc571da8a8e"; + public const string CEF_API_HASH_PLATFORM_LINUX = "8aba464ae9af72f65a1584199dd81fc3557c75b1"; } } diff --git a/UPGRADE.md b/UPGRADE.md index 541ad5e..2dc67e9 100644 --- a/UPGRADE.md +++ b/UPGRADE.md @@ -77,6 +77,24 @@ This file is consumed by: | `CefRuntime/make_cefredist_osx.sh` | `grep` + `sed` | | `.github/workflows/build-cef-packages.yml` | `cefbuildversion` workflow input (set when triggering manually) | +### `cef_version` and `cef_build_version` describe different things here + +This fork binds a CEF we build ourselves: the ReadyM surface-lease build, published as a release asset on +`readycodeio/cef` rather than on the Spotify CDN. So the two version fields no longer name the same release, +and each has to keep naming what its own consumers can actually resolve. + +- **`cef_build_version` is the CEF the bindings target.** `CefGlue.Interop.Gen/include/` holds that build's + headers and `CefGlue/Interop/version.g.cs` is generated from them, so this is the build a host must ship for + the interop to be correct. Its Windows binaries come from the GitHub release, not from a package feed. +- **`cef_version` stays an upstream release number**, because `Directory.Packages.props` pins + `chromiumembeddedframework.runtime[.win-x64/.win-arm64]` at `$(CefVersion)` and `CefGlue.Packages.props` + references them unconditionally. A value with no published package fails `restore` on every platform. It is + the closest upstream release, and it is what this repo's own tests and demos run against. + +One consequence worth knowing before you rely on it: the `cef.runtime.*` Linux and macOS packages are built by +downloading `cef_build_version` from the Spotify CDN, which does not host our build. Those platforms are out of +scope for the surface lease, which is Windows and D3D12 only. + ## Step-by-Step Upgrade Process (Manual / Full Reference) > **Note:** Steps 2–4 are automated by `upgrade-cef.ps1` / `upgrade-cef.sh` (see [Quick Upgrade](#quick-upgrade-automated) above). diff --git a/cef-version.json b/cef-version.json index 226db51..72fc2e4 100644 --- a/cef-version.json +++ b/cef-version.json @@ -1,7 +1,7 @@ { "cef_version": "150.0.17", - "cef_build_version": "150.0.17+g94c1726+chromium-150.0.7871.187", + "cef_build_version": "150.0.23-2026-08-04-surface-lease.3556+ge7ab2e1+chromium-150.0.7871.187", "chromium_version": "150.0.7871.187", "cefglue_version": "150.7871.187", - "cef_git_hash": "g94c1726" + "cef_git_hash": "ge7ab2e1" }