From bf20cae133e6b800b1647a01961646bf7e836f9f Mon Sep 17 00:00:00 2001 From: Juliusz Kopczewski Date: Fri, 7 Aug 2026 20:42:28 +0200 Subject: [PATCH 1/3] build(cef): vendor the ReadyM surface-lease build's headers The include tree was still the 150.0.11 baseline, so it did not contain ReleaseAcceleratedPaintSurface at all. The binding for it was added by hand and the version constants were set by hand to a build nobody had vendored, which left regeneration as a trap: it would have quietly deleted the binding. Overlays the headers from the build we actually ship, cef_binary_150.0.23- 2026-08-04-surface-lease.3556+ge7ab2e1+chromium-150.0.7871.187_windows64_readym, and regenerates version.g.cs from them, so the constants now name that build rather than the stock 150.0.17 they claimed. cef_version stays an upstream release number on purpose. Directory.Packages.props pins chromiumembeddedframework.runtime at $(CefVersion) and CefGlue.Packages.props references it unconditionally, so a value with no published package fails restore everywhere. UPGRADE.md now explains why the two version fields diverge. --- CefGlue.Interop.Gen/include/cef_api_versions.h | 10 +++++----- CefGlue.Interop.Gen/include/cef_browser.h | 16 ++++++++++++++++ .../include/cef_render_handler.h | 17 ++++++++++------- CefGlue.Interop.Gen/include/cef_version.h | 10 +++++----- .../include/internal/cef_types_osr.h | 14 ++++++++++++++ .../include/internal/cef_types_win.h | 5 +++-- CefGlue/Interop/version.g.cs | 6 +++--- UPGRADE.md | 18 ++++++++++++++++++ cef-version.json | 4 ++-- 9 files changed, 76 insertions(+), 24 deletions(-) diff --git a/CefGlue.Interop.Gen/include/cef_api_versions.h b/CefGlue.Interop.Gen/include/cef_api_versions.h index b20e7428..c6265d30 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 0c27c15e..5f0dc830 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 332a113c..10525501 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 fe2d6530..d8696981 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 0664cfa1..d71d3f5a 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 a812c33d..1d8e4c74 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/version.g.cs b/CefGlue/Interop/version.g.cs index 0acc88d5..0dc611ea 100644 --- a/CefGlue/Interop/version.g.cs +++ b/CefGlue/Interop/version.g.cs @@ -9,10 +9,10 @@ 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; diff --git a/UPGRADE.md b/UPGRADE.md index 541ad5ef..2dc67e90 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 226db51b..72fc2e47 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" } From 9aa3b576052eac32807e0ec6e377051e1b002ff9 Mon Sep 17 00:00:00 2001 From: Juliusz Kopczewski Date: Fri, 7 Aug 2026 20:42:45 +0200 Subject: [PATCH 2/3] fix(interop): order struct members by the version that added them The generated structs mirror CEF's C API structs field for field, so their order is ABI. The generator emitted C++ declaration order; CEF's own translator emits version order, appending members added by a later API version after every member of earlier ones. That is what keeps a client built against an older version finding the members it knows at the offsets it expects. Where the two disagreed, a member landed mid-struct and silently shifted every member below it, so calls dispatched through the wrong function pointer. cef_browser_host_t was the worst: release_accelerated_paint_surface sat 30 slots early, which put send_key_event onward and everything through get_runtime_style on the wrong entry. cef_command_line_t, cef_download_item_t and cef_request_context_t were wrong the same way, and had been before we patched anything, since the cause is any method carrying an added= annotation. Sorts by added version, stably, so declaration order still decides within a version. Verified by extracting the field order of all 130 generated structs and diffing each against the corresponding capi struct in the CEF distribution we ship: all 130 now match, resolving inherited bases and treating cef_base_ref_counted_t as the opaque _base field the generator emits. --- CefGlue.Interop.Gen/make_interop.py | 25 +- .../Interop/Classes.g/cef_browser_host_t.g.cs | 288 +++++++++--------- .../Interop/Classes.g/cef_command_line_t.g.cs | 78 ++--- .../Classes.g/cef_download_item_t.g.cs | 158 +++++----- .../Classes.g/cef_request_context_t.g.cs | 190 ++++++------ 5 files changed, 381 insertions(+), 358 deletions(-) diff --git a/CefGlue.Interop.Gen/make_interop.py b/CefGlue.Interop.Gen/make_interop.py index b79839e3..0f5d35a3 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 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 bdcfeb42..969bfe5b 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 a75904e5..9c827ff7 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 5d7a4683..b7bf124a 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 9b11ee38..16451e93 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); + } + } } From 1a3edff44634ca0cb1451727b9493e97fb972ce1 Mon Sep 17 00:00:00 2001 From: Juliusz Kopczewski Date: Fri, 7 Aug 2026 21:29:50 +0200 Subject: [PATCH 3/3] fix(interop): declare the experimental API version, not the last numbered one A client announces its API version by calling cef_api_hash(version) before initializing, and the library then builds its C API structs to match. This is not bookkeeping: announce an explicit version and every method added since is compiled out of those structs, so a binding that knows about a newer method reads a different method's pointer, or reads past the end of the struct. The generator picked CEF_API_VERSION_LAST, so the bindings announced 15000 while being generated from the experimental headers. Calling ReleaseAcceleratedPaintSurface then jumped through whatever that field position holds in a 15000-layout struct and took the process down with an access violation. Our own additions live in the experimental surface, since that is where CEF puts API not yet frozen into a numbered version, so that is the version to announce. It costs the forward and backward compatibility an explicit version buys across a range of CEF releases, which is a fair trade while we ship the libcef we bind against. Verified by running a browser through the managed harness: 368 accelerated paints, every one carrying a lease id, every lease released, clean shutdown. Before this change the same run died on the first release call. --- CefGlue.Interop.Gen/make_interop.py | 31 +++++++++++++++++++---------- CefGlue/Interop/version.g.cs | 8 ++++---- 2 files changed, 25 insertions(+), 14 deletions(-) diff --git a/CefGlue.Interop.Gen/make_interop.py b/CefGlue.Interop.Gen/make_interop.py index 0f5d35a3..d8bd6c0c 100644 --- a/CefGlue.Interop.Gen/make_interop.py +++ b/CefGlue.Interop.Gen/make_interop.py @@ -846,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"]) @@ -873,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/version.g.cs b/CefGlue/Interop/version.g.cs index 0dc611ea..d1b240ed 100644 --- a/CefGlue/Interop/version.g.cs +++ b/CefGlue/Interop/version.g.cs @@ -19,9 +19,9 @@ internal static unsafe partial class libcef 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"; } }