init lserp cs 5.0

插件库/CommonLib/Cef3.24/Classes.g/CefApp.g.cs

@@ -0,0 +1,111 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefApp
+    {
+        private static Dictionary<IntPtr, CefApp> _roots = new Dictionary<IntPtr, CefApp>();
+        
+        private int _refct;
+        private cef_app_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_app_t.add_ref_delegate _ds0;
+        private cef_app_t.release_delegate _ds1;
+        private cef_app_t.has_one_ref_delegate _ds2;
+        private cef_app_t.on_before_command_line_processing_delegate _ds3;
+        private cef_app_t.on_register_custom_schemes_delegate _ds4;
+        private cef_app_t.get_resource_bundle_handler_delegate _ds5;
+        private cef_app_t.get_browser_process_handler_delegate _ds6;
+        private cef_app_t.get_render_process_handler_delegate _ds7;
+        
+        protected CefApp()
+        {
+            _self = cef_app_t.Alloc();
+        
+            _ds0 = new cef_app_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_app_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_app_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_app_t.on_before_command_line_processing_delegate(on_before_command_line_processing);
+            _self->_on_before_command_line_processing = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_app_t.on_register_custom_schemes_delegate(on_register_custom_schemes);
+            _self->_on_register_custom_schemes = Marshal.GetFunctionPointerForDelegate(_ds4);
+            _ds5 = new cef_app_t.get_resource_bundle_handler_delegate(get_resource_bundle_handler);
+            _self->_get_resource_bundle_handler = Marshal.GetFunctionPointerForDelegate(_ds5);
+            _ds6 = new cef_app_t.get_browser_process_handler_delegate(get_browser_process_handler);
+            _self->_get_browser_process_handler = Marshal.GetFunctionPointerForDelegate(_ds6);
+            _ds7 = new cef_app_t.get_render_process_handler_delegate(get_render_process_handler);
+            _self->_get_render_process_handler = Marshal.GetFunctionPointerForDelegate(_ds7);
+        }
+        
+        ~CefApp()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_app_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_app_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_app_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_app_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_app_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_app_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefAuthCallback.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefAuthCallback : IDisposable
+    {
+        internal static CefAuthCallback FromNative(cef_auth_callback_t* ptr)
+        {
+            return new CefAuthCallback(ptr);
+        }
+        
+        internal static CefAuthCallback FromNativeOrNull(cef_auth_callback_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefAuthCallback(ptr);
+        }
+        
+        private cef_auth_callback_t* _self;
+        
+        private CefAuthCallback(cef_auth_callback_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefAuthCallback()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_auth_callback_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_auth_callback_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_auth_callback_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_auth_callback_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefBeforeDownloadCallback.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefBeforeDownloadCallback : IDisposable
+    {
+        internal static CefBeforeDownloadCallback FromNative(cef_before_download_callback_t* ptr)
+        {
+            return new CefBeforeDownloadCallback(ptr);
+        }
+        
+        internal static CefBeforeDownloadCallback FromNativeOrNull(cef_before_download_callback_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefBeforeDownloadCallback(ptr);
+        }
+        
+        private cef_before_download_callback_t* _self;
+        
+        private CefBeforeDownloadCallback(cef_before_download_callback_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefBeforeDownloadCallback()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_before_download_callback_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_before_download_callback_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_before_download_callback_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_before_download_callback_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefBinaryValue.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefBinaryValue : IDisposable
+    {
+        internal static CefBinaryValue FromNative(cef_binary_value_t* ptr)
+        {
+            return new CefBinaryValue(ptr);
+        }
+        
+        internal static CefBinaryValue FromNativeOrNull(cef_binary_value_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefBinaryValue(ptr);
+        }
+        
+        private cef_binary_value_t* _self;
+        
+        private CefBinaryValue(cef_binary_value_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefBinaryValue()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_binary_value_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_binary_value_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_binary_value_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_binary_value_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefBrowser.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefBrowser : IDisposable
+    {
+        internal static CefBrowser FromNative(cef_browser_t* ptr)
+        {
+            return new CefBrowser(ptr);
+        }
+        
+        internal static CefBrowser FromNativeOrNull(cef_browser_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefBrowser(ptr);
+        }
+        
+        private cef_browser_t* _self;
+        
+        private CefBrowser(cef_browser_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefBrowser()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_browser_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_browser_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_browser_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_browser_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefBrowserHost.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefBrowserHost : IDisposable
+    {
+        internal static CefBrowserHost FromNative(cef_browser_host_t* ptr)
+        {
+            return new CefBrowserHost(ptr);
+        }
+        
+        internal static CefBrowserHost FromNativeOrNull(cef_browser_host_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefBrowserHost(ptr);
+        }
+        
+        private cef_browser_host_t* _self;
+        
+        private CefBrowserHost(cef_browser_host_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefBrowserHost()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_browser_host_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_browser_host_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_browser_host_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_browser_host_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefBrowserProcessHandler.g.cs

@@ -0,0 +1,108 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefBrowserProcessHandler
+    {
+        private static Dictionary<IntPtr, CefBrowserProcessHandler> _roots = new Dictionary<IntPtr, CefBrowserProcessHandler>();
+        
+        private int _refct;
+        private cef_browser_process_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_browser_process_handler_t.add_ref_delegate _ds0;
+        private cef_browser_process_handler_t.release_delegate _ds1;
+        private cef_browser_process_handler_t.has_one_ref_delegate _ds2;
+        private cef_browser_process_handler_t.on_context_initialized_delegate _ds3;
+        private cef_browser_process_handler_t.on_before_child_process_launch_delegate _ds4;
+        private cef_browser_process_handler_t.on_render_process_thread_created_delegate _ds5;
+        private cef_browser_process_handler_t.get_print_handler_delegate _ds6;
+        
+        protected CefBrowserProcessHandler()
+        {
+            _self = cef_browser_process_handler_t.Alloc();
+        
+            _ds0 = new cef_browser_process_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_browser_process_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_browser_process_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_browser_process_handler_t.on_context_initialized_delegate(on_context_initialized);
+            _self->_on_context_initialized = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_browser_process_handler_t.on_before_child_process_launch_delegate(on_before_child_process_launch);
+            _self->_on_before_child_process_launch = Marshal.GetFunctionPointerForDelegate(_ds4);
+            _ds5 = new cef_browser_process_handler_t.on_render_process_thread_created_delegate(on_render_process_thread_created);
+            _self->_on_render_process_thread_created = Marshal.GetFunctionPointerForDelegate(_ds5);
+            _ds6 = new cef_browser_process_handler_t.get_print_handler_delegate(get_print_handler);
+            _self->_get_print_handler = Marshal.GetFunctionPointerForDelegate(_ds6);
+        }
+        
+        ~CefBrowserProcessHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_browser_process_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_browser_process_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_browser_process_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_browser_process_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_browser_process_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_browser_process_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefCallback.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefCallback : IDisposable
+    {
+        internal static CefCallback FromNative(cef_callback_t* ptr)
+        {
+            return new CefCallback(ptr);
+        }
+        
+        internal static CefCallback FromNativeOrNull(cef_callback_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefCallback(ptr);
+        }
+        
+        private cef_callback_t* _self;
+        
+        private CefCallback(cef_callback_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefCallback()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_callback_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_callback_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_callback_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_callback_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefClient.g.cs

@@ -0,0 +1,159 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefClient
+    {
+        private static Dictionary<IntPtr, CefClient> _roots = new Dictionary<IntPtr, CefClient>();
+        
+        private int _refct;
+        private cef_client_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        internal static CefClient FromNativeOrNull(cef_client_t* ptr)
+        {
+            CefClient value = null;
+            bool found;
+            lock (_roots)
+            {
+                found = _roots.TryGetValue((IntPtr)ptr, out value);
+            }
+            return found ? value : null;
+        }
+        
+        internal static CefClient FromNative(cef_client_t* ptr)
+        {
+            var value = FromNativeOrNull(ptr);
+            if (value == null) throw ExceptionBuilder.ObjectNotFound();
+            return value;
+        }
+        
+        private cef_client_t.add_ref_delegate _ds0;
+        private cef_client_t.release_delegate _ds1;
+        private cef_client_t.has_one_ref_delegate _ds2;
+        private cef_client_t.get_context_menu_handler_delegate _ds3;
+        private cef_client_t.get_dialog_handler_delegate _ds4;
+        private cef_client_t.get_display_handler_delegate _ds5;
+        private cef_client_t.get_download_handler_delegate _ds6;
+        private cef_client_t.get_drag_handler_delegate _ds7;
+        private cef_client_t.get_find_handler_delegate _ds8;
+        private cef_client_t.get_focus_handler_delegate _ds9;
+        private cef_client_t.get_geolocation_handler_delegate _dsa;
+        private cef_client_t.get_jsdialog_handler_delegate _dsb;
+        private cef_client_t.get_keyboard_handler_delegate _dsc;
+        private cef_client_t.get_life_span_handler_delegate _dsd;
+        private cef_client_t.get_load_handler_delegate _dse;
+        private cef_client_t.get_render_handler_delegate _dsf;
+        private cef_client_t.get_request_handler_delegate _ds10;
+        private cef_client_t.on_process_message_received_delegate _ds11;
+        
+        protected CefClient()
+        {
+            _self = cef_client_t.Alloc();
+        
+            _ds0 = new cef_client_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_client_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_client_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_client_t.get_context_menu_handler_delegate(get_context_menu_handler);
+            _self->_get_context_menu_handler = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_client_t.get_dialog_handler_delegate(get_dialog_handler);
+            _self->_get_dialog_handler = Marshal.GetFunctionPointerForDelegate(_ds4);
+            _ds5 = new cef_client_t.get_display_handler_delegate(get_display_handler);
+            _self->_get_display_handler = Marshal.GetFunctionPointerForDelegate(_ds5);
+            _ds6 = new cef_client_t.get_download_handler_delegate(get_download_handler);
+            _self->_get_download_handler = Marshal.GetFunctionPointerForDelegate(_ds6);
+            _ds7 = new cef_client_t.get_drag_handler_delegate(get_drag_handler);
+            _self->_get_drag_handler = Marshal.GetFunctionPointerForDelegate(_ds7);
+            _ds8 = new cef_client_t.get_find_handler_delegate(get_find_handler);
+            _self->_get_find_handler = Marshal.GetFunctionPointerForDelegate(_ds8);
+            _ds9 = new cef_client_t.get_focus_handler_delegate(get_focus_handler);
+            _self->_get_focus_handler = Marshal.GetFunctionPointerForDelegate(_ds9);
+            _dsa = new cef_client_t.get_geolocation_handler_delegate(get_geolocation_handler);
+            _self->_get_geolocation_handler = Marshal.GetFunctionPointerForDelegate(_dsa);
+            _dsb = new cef_client_t.get_jsdialog_handler_delegate(get_jsdialog_handler);
+            _self->_get_jsdialog_handler = Marshal.GetFunctionPointerForDelegate(_dsb);
+            _dsc = new cef_client_t.get_keyboard_handler_delegate(get_keyboard_handler);
+            _self->_get_keyboard_handler = Marshal.GetFunctionPointerForDelegate(_dsc);
+            _dsd = new cef_client_t.get_life_span_handler_delegate(get_life_span_handler);
+            _self->_get_life_span_handler = Marshal.GetFunctionPointerForDelegate(_dsd);
+            _dse = new cef_client_t.get_load_handler_delegate(get_load_handler);
+            _self->_get_load_handler = Marshal.GetFunctionPointerForDelegate(_dse);
+            _dsf = new cef_client_t.get_render_handler_delegate(get_render_handler);
+            _self->_get_render_handler = Marshal.GetFunctionPointerForDelegate(_dsf);
+            _ds10 = new cef_client_t.get_request_handler_delegate(get_request_handler);
+            _self->_get_request_handler = Marshal.GetFunctionPointerForDelegate(_ds10);
+            _ds11 = new cef_client_t.on_process_message_received_delegate(on_process_message_received);
+            _self->_on_process_message_received = Marshal.GetFunctionPointerForDelegate(_ds11);
+        }
+        
+        ~CefClient()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_client_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_client_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_client_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_client_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_client_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_client_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefCommandLine.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefCommandLine : IDisposable
+    {
+        internal static CefCommandLine FromNative(cef_command_line_t* ptr)
+        {
+            return new CefCommandLine(ptr);
+        }
+        
+        internal static CefCommandLine FromNativeOrNull(cef_command_line_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefCommandLine(ptr);
+        }
+        
+        private cef_command_line_t* _self;
+        
+        private CefCommandLine(cef_command_line_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefCommandLine()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_command_line_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_command_line_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_command_line_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_command_line_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefCompletionCallback.g.cs

@@ -0,0 +1,99 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefCompletionCallback
+    {
+        private static Dictionary<IntPtr, CefCompletionCallback> _roots = new Dictionary<IntPtr, CefCompletionCallback>();
+        
+        private int _refct;
+        private cef_completion_callback_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_completion_callback_t.add_ref_delegate _ds0;
+        private cef_completion_callback_t.release_delegate _ds1;
+        private cef_completion_callback_t.has_one_ref_delegate _ds2;
+        private cef_completion_callback_t.on_complete_delegate _ds3;
+        
+        protected CefCompletionCallback()
+        {
+            _self = cef_completion_callback_t.Alloc();
+        
+            _ds0 = new cef_completion_callback_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_completion_callback_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_completion_callback_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_completion_callback_t.on_complete_delegate(on_complete);
+            _self->_on_complete = Marshal.GetFunctionPointerForDelegate(_ds3);
+        }
+        
+        ~CefCompletionCallback()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_completion_callback_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_completion_callback_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_completion_callback_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_completion_callback_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_completion_callback_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_completion_callback_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefContextMenuHandler.g.cs

@@ -0,0 +1,105 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefContextMenuHandler
+    {
+        private static Dictionary<IntPtr, CefContextMenuHandler> _roots = new Dictionary<IntPtr, CefContextMenuHandler>();
+        
+        private int _refct;
+        private cef_context_menu_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_context_menu_handler_t.add_ref_delegate _ds0;
+        private cef_context_menu_handler_t.release_delegate _ds1;
+        private cef_context_menu_handler_t.has_one_ref_delegate _ds2;
+        private cef_context_menu_handler_t.on_before_context_menu_delegate _ds3;
+        private cef_context_menu_handler_t.on_context_menu_command_delegate _ds4;
+        private cef_context_menu_handler_t.on_context_menu_dismissed_delegate _ds5;
+        
+        protected CefContextMenuHandler()
+        {
+            _self = cef_context_menu_handler_t.Alloc();
+        
+            _ds0 = new cef_context_menu_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_context_menu_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_context_menu_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_context_menu_handler_t.on_before_context_menu_delegate(on_before_context_menu);
+            _self->_on_before_context_menu = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_context_menu_handler_t.on_context_menu_command_delegate(on_context_menu_command);
+            _self->_on_context_menu_command = Marshal.GetFunctionPointerForDelegate(_ds4);
+            _ds5 = new cef_context_menu_handler_t.on_context_menu_dismissed_delegate(on_context_menu_dismissed);
+            _self->_on_context_menu_dismissed = Marshal.GetFunctionPointerForDelegate(_ds5);
+        }
+        
+        ~CefContextMenuHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_context_menu_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_context_menu_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_context_menu_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_context_menu_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_context_menu_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_context_menu_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefContextMenuParams.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefContextMenuParams : IDisposable
+    {
+        internal static CefContextMenuParams FromNative(cef_context_menu_params_t* ptr)
+        {
+            return new CefContextMenuParams(ptr);
+        }
+        
+        internal static CefContextMenuParams FromNativeOrNull(cef_context_menu_params_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefContextMenuParams(ptr);
+        }
+        
+        private cef_context_menu_params_t* _self;
+        
+        private CefContextMenuParams(cef_context_menu_params_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefContextMenuParams()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_context_menu_params_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_context_menu_params_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_context_menu_params_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_context_menu_params_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefCookieManager.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefCookieManager : IDisposable
+    {
+        internal static CefCookieManager FromNative(cef_cookie_manager_t* ptr)
+        {
+            return new CefCookieManager(ptr);
+        }
+        
+        internal static CefCookieManager FromNativeOrNull(cef_cookie_manager_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefCookieManager(ptr);
+        }
+        
+        private cef_cookie_manager_t* _self;
+        
+        private CefCookieManager(cef_cookie_manager_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefCookieManager()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_cookie_manager_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_cookie_manager_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_cookie_manager_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_cookie_manager_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefCookieVisitor.g.cs

@@ -0,0 +1,99 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefCookieVisitor
+    {
+        private static Dictionary<IntPtr, CefCookieVisitor> _roots = new Dictionary<IntPtr, CefCookieVisitor>();
+        
+        private int _refct;
+        private cef_cookie_visitor_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_cookie_visitor_t.add_ref_delegate _ds0;
+        private cef_cookie_visitor_t.release_delegate _ds1;
+        private cef_cookie_visitor_t.has_one_ref_delegate _ds2;
+        private cef_cookie_visitor_t.visit_delegate _ds3;
+        
+        protected CefCookieVisitor()
+        {
+            _self = cef_cookie_visitor_t.Alloc();
+        
+            _ds0 = new cef_cookie_visitor_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_cookie_visitor_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_cookie_visitor_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_cookie_visitor_t.visit_delegate(visit);
+            _self->_visit = Marshal.GetFunctionPointerForDelegate(_ds3);
+        }
+        
+        ~CefCookieVisitor()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_cookie_visitor_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_cookie_visitor_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_cookie_visitor_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_cookie_visitor_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_cookie_visitor_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_cookie_visitor_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefDeleteCookiesCallback.g.cs

@@ -0,0 +1,99 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefDeleteCookiesCallback
+    {
+        private static Dictionary<IntPtr, CefDeleteCookiesCallback> _roots = new Dictionary<IntPtr, CefDeleteCookiesCallback>();
+        
+        private int _refct;
+        private cef_delete_cookies_callback_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_delete_cookies_callback_t.add_ref_delegate _ds0;
+        private cef_delete_cookies_callback_t.release_delegate _ds1;
+        private cef_delete_cookies_callback_t.has_one_ref_delegate _ds2;
+        private cef_delete_cookies_callback_t.on_complete_delegate _ds3;
+        
+        protected CefDeleteCookiesCallback()
+        {
+            _self = cef_delete_cookies_callback_t.Alloc();
+        
+            _ds0 = new cef_delete_cookies_callback_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_delete_cookies_callback_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_delete_cookies_callback_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_delete_cookies_callback_t.on_complete_delegate(on_complete);
+            _self->_on_complete = Marshal.GetFunctionPointerForDelegate(_ds3);
+        }
+        
+        ~CefDeleteCookiesCallback()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_delete_cookies_callback_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_delete_cookies_callback_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_delete_cookies_callback_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_delete_cookies_callback_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_delete_cookies_callback_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_delete_cookies_callback_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefDialogHandler.g.cs

@@ -0,0 +1,99 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefDialogHandler
+    {
+        private static Dictionary<IntPtr, CefDialogHandler> _roots = new Dictionary<IntPtr, CefDialogHandler>();
+        
+        private int _refct;
+        private cef_dialog_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_dialog_handler_t.add_ref_delegate _ds0;
+        private cef_dialog_handler_t.release_delegate _ds1;
+        private cef_dialog_handler_t.has_one_ref_delegate _ds2;
+        private cef_dialog_handler_t.on_file_dialog_delegate _ds3;
+        
+        protected CefDialogHandler()
+        {
+            _self = cef_dialog_handler_t.Alloc();
+        
+            _ds0 = new cef_dialog_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_dialog_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_dialog_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_dialog_handler_t.on_file_dialog_delegate(on_file_dialog);
+            _self->_on_file_dialog = Marshal.GetFunctionPointerForDelegate(_ds3);
+        }
+        
+        ~CefDialogHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_dialog_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_dialog_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_dialog_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_dialog_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_dialog_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_dialog_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefDictionaryValue.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefDictionaryValue : IDisposable
+    {
+        internal static CefDictionaryValue FromNative(cef_dictionary_value_t* ptr)
+        {
+            return new CefDictionaryValue(ptr);
+        }
+        
+        internal static CefDictionaryValue FromNativeOrNull(cef_dictionary_value_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefDictionaryValue(ptr);
+        }
+        
+        private cef_dictionary_value_t* _self;
+        
+        private CefDictionaryValue(cef_dictionary_value_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefDictionaryValue()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_dictionary_value_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_dictionary_value_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_dictionary_value_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_dictionary_value_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefDisplayHandler.g.cs

@@ -0,0 +1,117 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefDisplayHandler
+    {
+        private static Dictionary<IntPtr, CefDisplayHandler> _roots = new Dictionary<IntPtr, CefDisplayHandler>();
+        
+        private int _refct;
+        private cef_display_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_display_handler_t.add_ref_delegate _ds0;
+        private cef_display_handler_t.release_delegate _ds1;
+        private cef_display_handler_t.has_one_ref_delegate _ds2;
+        private cef_display_handler_t.on_address_change_delegate _ds3;
+        private cef_display_handler_t.on_title_change_delegate _ds4;
+        private cef_display_handler_t.on_favicon_urlchange_delegate _ds5;
+        private cef_display_handler_t.on_fullscreen_mode_change_delegate _ds6;
+        private cef_display_handler_t.on_tooltip_delegate _ds7;
+        private cef_display_handler_t.on_status_message_delegate _ds8;
+        private cef_display_handler_t.on_console_message_delegate _ds9;
+        
+        protected CefDisplayHandler()
+        {
+            _self = cef_display_handler_t.Alloc();
+        
+            _ds0 = new cef_display_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_display_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_display_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_display_handler_t.on_address_change_delegate(on_address_change);
+            _self->_on_address_change = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_display_handler_t.on_title_change_delegate(on_title_change);
+            _self->_on_title_change = Marshal.GetFunctionPointerForDelegate(_ds4);
+            _ds5 = new cef_display_handler_t.on_favicon_urlchange_delegate(on_favicon_urlchange);
+            _self->_on_favicon_urlchange = Marshal.GetFunctionPointerForDelegate(_ds5);
+            _ds6 = new cef_display_handler_t.on_fullscreen_mode_change_delegate(on_fullscreen_mode_change);
+            _self->_on_fullscreen_mode_change = Marshal.GetFunctionPointerForDelegate(_ds6);
+            _ds7 = new cef_display_handler_t.on_tooltip_delegate(on_tooltip);
+            _self->_on_tooltip = Marshal.GetFunctionPointerForDelegate(_ds7);
+            _ds8 = new cef_display_handler_t.on_status_message_delegate(on_status_message);
+            _self->_on_status_message = Marshal.GetFunctionPointerForDelegate(_ds8);
+            _ds9 = new cef_display_handler_t.on_console_message_delegate(on_console_message);
+            _self->_on_console_message = Marshal.GetFunctionPointerForDelegate(_ds9);
+        }
+        
+        ~CefDisplayHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_display_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_display_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_display_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_display_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_display_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_display_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefDomDocument.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefDomDocument : IDisposable
+    {
+        internal static CefDomDocument FromNative(cef_domdocument_t* ptr)
+        {
+            return new CefDomDocument(ptr);
+        }
+        
+        internal static CefDomDocument FromNativeOrNull(cef_domdocument_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefDomDocument(ptr);
+        }
+        
+        private cef_domdocument_t* _self;
+        
+        private CefDomDocument(cef_domdocument_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefDomDocument()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_domdocument_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_domdocument_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_domdocument_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_domdocument_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefDomEvent.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefDomEvent : IDisposable
+    {
+        internal static CefDomEvent FromNative(cef_domevent_t* ptr)
+        {
+            return new CefDomEvent(ptr);
+        }
+        
+        internal static CefDomEvent FromNativeOrNull(cef_domevent_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefDomEvent(ptr);
+        }
+        
+        private cef_domevent_t* _self;
+        
+        private CefDomEvent(cef_domevent_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefDomEvent()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_domevent_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_domevent_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_domevent_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_domevent_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefDomNode.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefDomNode : IDisposable
+    {
+        internal static CefDomNode FromNative(cef_domnode_t* ptr)
+        {
+            return new CefDomNode(ptr);
+        }
+        
+        internal static CefDomNode FromNativeOrNull(cef_domnode_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefDomNode(ptr);
+        }
+        
+        private cef_domnode_t* _self;
+        
+        private CefDomNode(cef_domnode_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefDomNode()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_domnode_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_domnode_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_domnode_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_domnode_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefDomVisitor.g.cs

@@ -0,0 +1,99 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefDomVisitor
+    {
+        private static Dictionary<IntPtr, CefDomVisitor> _roots = new Dictionary<IntPtr, CefDomVisitor>();
+        
+        private int _refct;
+        private cef_domvisitor_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_domvisitor_t.add_ref_delegate _ds0;
+        private cef_domvisitor_t.release_delegate _ds1;
+        private cef_domvisitor_t.has_one_ref_delegate _ds2;
+        private cef_domvisitor_t.visit_delegate _ds3;
+        
+        protected CefDomVisitor()
+        {
+            _self = cef_domvisitor_t.Alloc();
+        
+            _ds0 = new cef_domvisitor_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_domvisitor_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_domvisitor_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_domvisitor_t.visit_delegate(visit);
+            _self->_visit = Marshal.GetFunctionPointerForDelegate(_ds3);
+        }
+        
+        ~CefDomVisitor()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_domvisitor_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_domvisitor_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_domvisitor_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_domvisitor_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_domvisitor_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_domvisitor_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefDownloadHandler.g.cs

@@ -0,0 +1,102 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefDownloadHandler
+    {
+        private static Dictionary<IntPtr, CefDownloadHandler> _roots = new Dictionary<IntPtr, CefDownloadHandler>();
+        
+        private int _refct;
+        private cef_download_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_download_handler_t.add_ref_delegate _ds0;
+        private cef_download_handler_t.release_delegate _ds1;
+        private cef_download_handler_t.has_one_ref_delegate _ds2;
+        private cef_download_handler_t.on_before_download_delegate _ds3;
+        private cef_download_handler_t.on_download_updated_delegate _ds4;
+        
+        protected CefDownloadHandler()
+        {
+            _self = cef_download_handler_t.Alloc();
+        
+            _ds0 = new cef_download_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_download_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_download_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_download_handler_t.on_before_download_delegate(on_before_download);
+            _self->_on_before_download = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_download_handler_t.on_download_updated_delegate(on_download_updated);
+            _self->_on_download_updated = Marshal.GetFunctionPointerForDelegate(_ds4);
+        }
+        
+        ~CefDownloadHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_download_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_download_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_download_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_download_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_download_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_download_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefDownloadItem.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefDownloadItem : IDisposable
+    {
+        internal static CefDownloadItem FromNative(cef_download_item_t* ptr)
+        {
+            return new CefDownloadItem(ptr);
+        }
+        
+        internal static CefDownloadItem FromNativeOrNull(cef_download_item_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefDownloadItem(ptr);
+        }
+        
+        private cef_download_item_t* _self;
+        
+        private CefDownloadItem(cef_download_item_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefDownloadItem()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_download_item_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_download_item_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_download_item_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_download_item_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefDownloadItemCallback.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefDownloadItemCallback : IDisposable
+    {
+        internal static CefDownloadItemCallback FromNative(cef_download_item_callback_t* ptr)
+        {
+            return new CefDownloadItemCallback(ptr);
+        }
+        
+        internal static CefDownloadItemCallback FromNativeOrNull(cef_download_item_callback_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefDownloadItemCallback(ptr);
+        }
+        
+        private cef_download_item_callback_t* _self;
+        
+        private CefDownloadItemCallback(cef_download_item_callback_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefDownloadItemCallback()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_download_item_callback_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_download_item_callback_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_download_item_callback_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_download_item_callback_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefDragData.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefDragData : IDisposable
+    {
+        internal static CefDragData FromNative(cef_drag_data_t* ptr)
+        {
+            return new CefDragData(ptr);
+        }
+        
+        internal static CefDragData FromNativeOrNull(cef_drag_data_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefDragData(ptr);
+        }
+        
+        private cef_drag_data_t* _self;
+        
+        private CefDragData(cef_drag_data_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefDragData()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_drag_data_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_drag_data_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_drag_data_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_drag_data_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefDragHandler.g.cs

@@ -0,0 +1,102 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefDragHandler
+    {
+        private static Dictionary<IntPtr, CefDragHandler> _roots = new Dictionary<IntPtr, CefDragHandler>();
+        
+        private int _refct;
+        private cef_drag_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_drag_handler_t.add_ref_delegate _ds0;
+        private cef_drag_handler_t.release_delegate _ds1;
+        private cef_drag_handler_t.has_one_ref_delegate _ds2;
+        private cef_drag_handler_t.on_drag_enter_delegate _ds3;
+        private cef_drag_handler_t.on_draggable_regions_changed_delegate _ds4;
+        
+        protected CefDragHandler()
+        {
+            _self = cef_drag_handler_t.Alloc();
+        
+            _ds0 = new cef_drag_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_drag_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_drag_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_drag_handler_t.on_drag_enter_delegate(on_drag_enter);
+            _self->_on_drag_enter = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_drag_handler_t.on_draggable_regions_changed_delegate(on_draggable_regions_changed);
+            _self->_on_draggable_regions_changed = Marshal.GetFunctionPointerForDelegate(_ds4);
+        }
+        
+        ~CefDragHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_drag_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_drag_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_drag_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_drag_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_drag_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_drag_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefEndTracingCallback.g.cs

@@ -0,0 +1,99 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefEndTracingCallback
+    {
+        private static Dictionary<IntPtr, CefEndTracingCallback> _roots = new Dictionary<IntPtr, CefEndTracingCallback>();
+        
+        private int _refct;
+        private cef_end_tracing_callback_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_end_tracing_callback_t.add_ref_delegate _ds0;
+        private cef_end_tracing_callback_t.release_delegate _ds1;
+        private cef_end_tracing_callback_t.has_one_ref_delegate _ds2;
+        private cef_end_tracing_callback_t.on_end_tracing_complete_delegate _ds3;
+        
+        protected CefEndTracingCallback()
+        {
+            _self = cef_end_tracing_callback_t.Alloc();
+        
+            _ds0 = new cef_end_tracing_callback_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_end_tracing_callback_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_end_tracing_callback_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_end_tracing_callback_t.on_end_tracing_complete_delegate(on_end_tracing_complete);
+            _self->_on_end_tracing_complete = Marshal.GetFunctionPointerForDelegate(_ds3);
+        }
+        
+        ~CefEndTracingCallback()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_end_tracing_callback_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_end_tracing_callback_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_end_tracing_callback_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_end_tracing_callback_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_end_tracing_callback_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_end_tracing_callback_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefFileDialogCallback.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefFileDialogCallback : IDisposable
+    {
+        internal static CefFileDialogCallback FromNative(cef_file_dialog_callback_t* ptr)
+        {
+            return new CefFileDialogCallback(ptr);
+        }
+        
+        internal static CefFileDialogCallback FromNativeOrNull(cef_file_dialog_callback_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefFileDialogCallback(ptr);
+        }
+        
+        private cef_file_dialog_callback_t* _self;
+        
+        private CefFileDialogCallback(cef_file_dialog_callback_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefFileDialogCallback()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_file_dialog_callback_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_file_dialog_callback_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_file_dialog_callback_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_file_dialog_callback_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefFindHandler.g.cs

@@ -0,0 +1,99 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefFindHandler
+    {
+        private static Dictionary<IntPtr, CefFindHandler> _roots = new Dictionary<IntPtr, CefFindHandler>();
+        
+        private int _refct;
+        private cef_find_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_find_handler_t.add_ref_delegate _ds0;
+        private cef_find_handler_t.release_delegate _ds1;
+        private cef_find_handler_t.has_one_ref_delegate _ds2;
+        private cef_find_handler_t.on_find_result_delegate _ds3;
+        
+        protected CefFindHandler()
+        {
+            _self = cef_find_handler_t.Alloc();
+        
+            _ds0 = new cef_find_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_find_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_find_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_find_handler_t.on_find_result_delegate(on_find_result);
+            _self->_on_find_result = Marshal.GetFunctionPointerForDelegate(_ds3);
+        }
+        
+        ~CefFindHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_find_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_find_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_find_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_find_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_find_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_find_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefFocusHandler.g.cs

@@ -0,0 +1,105 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefFocusHandler
+    {
+        private static Dictionary<IntPtr, CefFocusHandler> _roots = new Dictionary<IntPtr, CefFocusHandler>();
+        
+        private int _refct;
+        private cef_focus_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_focus_handler_t.add_ref_delegate _ds0;
+        private cef_focus_handler_t.release_delegate _ds1;
+        private cef_focus_handler_t.has_one_ref_delegate _ds2;
+        private cef_focus_handler_t.on_take_focus_delegate _ds3;
+        private cef_focus_handler_t.on_set_focus_delegate _ds4;
+        private cef_focus_handler_t.on_got_focus_delegate _ds5;
+        
+        protected CefFocusHandler()
+        {
+            _self = cef_focus_handler_t.Alloc();
+        
+            _ds0 = new cef_focus_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_focus_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_focus_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_focus_handler_t.on_take_focus_delegate(on_take_focus);
+            _self->_on_take_focus = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_focus_handler_t.on_set_focus_delegate(on_set_focus);
+            _self->_on_set_focus = Marshal.GetFunctionPointerForDelegate(_ds4);
+            _ds5 = new cef_focus_handler_t.on_got_focus_delegate(on_got_focus);
+            _self->_on_got_focus = Marshal.GetFunctionPointerForDelegate(_ds5);
+        }
+        
+        ~CefFocusHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_focus_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_focus_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_focus_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_focus_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_focus_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_focus_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefFrame.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefFrame : IDisposable
+    {
+        internal static CefFrame FromNative(cef_frame_t* ptr)
+        {
+            return new CefFrame(ptr);
+        }
+        
+        internal static CefFrame FromNativeOrNull(cef_frame_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefFrame(ptr);
+        }
+        
+        private cef_frame_t* _self;
+        
+        private CefFrame(cef_frame_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefFrame()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_frame_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_frame_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_frame_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_frame_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefGeolocationCallback.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefGeolocationCallback : IDisposable
+    {
+        internal static CefGeolocationCallback FromNative(cef_geolocation_callback_t* ptr)
+        {
+            return new CefGeolocationCallback(ptr);
+        }
+        
+        internal static CefGeolocationCallback FromNativeOrNull(cef_geolocation_callback_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefGeolocationCallback(ptr);
+        }
+        
+        private cef_geolocation_callback_t* _self;
+        
+        private CefGeolocationCallback(cef_geolocation_callback_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefGeolocationCallback()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_geolocation_callback_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_geolocation_callback_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_geolocation_callback_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_geolocation_callback_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefGeolocationHandler.g.cs

@@ -0,0 +1,102 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefGeolocationHandler
+    {
+        private static Dictionary<IntPtr, CefGeolocationHandler> _roots = new Dictionary<IntPtr, CefGeolocationHandler>();
+        
+        private int _refct;
+        private cef_geolocation_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_geolocation_handler_t.add_ref_delegate _ds0;
+        private cef_geolocation_handler_t.release_delegate _ds1;
+        private cef_geolocation_handler_t.has_one_ref_delegate _ds2;
+        private cef_geolocation_handler_t.on_request_geolocation_permission_delegate _ds3;
+        private cef_geolocation_handler_t.on_cancel_geolocation_permission_delegate _ds4;
+        
+        protected CefGeolocationHandler()
+        {
+            _self = cef_geolocation_handler_t.Alloc();
+        
+            _ds0 = new cef_geolocation_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_geolocation_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_geolocation_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_geolocation_handler_t.on_request_geolocation_permission_delegate(on_request_geolocation_permission);
+            _self->_on_request_geolocation_permission = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_geolocation_handler_t.on_cancel_geolocation_permission_delegate(on_cancel_geolocation_permission);
+            _self->_on_cancel_geolocation_permission = Marshal.GetFunctionPointerForDelegate(_ds4);
+        }
+        
+        ~CefGeolocationHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_geolocation_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_geolocation_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_geolocation_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_geolocation_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_geolocation_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_geolocation_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefGetGeolocationCallback.g.cs

@@ -0,0 +1,99 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefGetGeolocationCallback
+    {
+        private static Dictionary<IntPtr, CefGetGeolocationCallback> _roots = new Dictionary<IntPtr, CefGetGeolocationCallback>();
+        
+        private int _refct;
+        private cef_get_geolocation_callback_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_get_geolocation_callback_t.add_ref_delegate _ds0;
+        private cef_get_geolocation_callback_t.release_delegate _ds1;
+        private cef_get_geolocation_callback_t.has_one_ref_delegate _ds2;
+        private cef_get_geolocation_callback_t.on_location_update_delegate _ds3;
+        
+        protected CefGetGeolocationCallback()
+        {
+            _self = cef_get_geolocation_callback_t.Alloc();
+        
+            _ds0 = new cef_get_geolocation_callback_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_get_geolocation_callback_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_get_geolocation_callback_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_get_geolocation_callback_t.on_location_update_delegate(on_location_update);
+            _self->_on_location_update = Marshal.GetFunctionPointerForDelegate(_ds3);
+        }
+        
+        ~CefGetGeolocationCallback()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_get_geolocation_callback_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_get_geolocation_callback_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_get_geolocation_callback_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_get_geolocation_callback_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_get_geolocation_callback_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_get_geolocation_callback_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefJSDialogCallback.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefJSDialogCallback : IDisposable
+    {
+        internal static CefJSDialogCallback FromNative(cef_jsdialog_callback_t* ptr)
+        {
+            return new CefJSDialogCallback(ptr);
+        }
+        
+        internal static CefJSDialogCallback FromNativeOrNull(cef_jsdialog_callback_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefJSDialogCallback(ptr);
+        }
+        
+        private cef_jsdialog_callback_t* _self;
+        
+        private CefJSDialogCallback(cef_jsdialog_callback_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefJSDialogCallback()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_jsdialog_callback_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_jsdialog_callback_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_jsdialog_callback_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_jsdialog_callback_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefJSDialogHandler.g.cs

@@ -0,0 +1,108 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefJSDialogHandler
+    {
+        private static Dictionary<IntPtr, CefJSDialogHandler> _roots = new Dictionary<IntPtr, CefJSDialogHandler>();
+        
+        private int _refct;
+        private cef_jsdialog_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_jsdialog_handler_t.add_ref_delegate _ds0;
+        private cef_jsdialog_handler_t.release_delegate _ds1;
+        private cef_jsdialog_handler_t.has_one_ref_delegate _ds2;
+        private cef_jsdialog_handler_t.on_jsdialog_delegate _ds3;
+        private cef_jsdialog_handler_t.on_before_unload_dialog_delegate _ds4;
+        private cef_jsdialog_handler_t.on_reset_dialog_state_delegate _ds5;
+        private cef_jsdialog_handler_t.on_dialog_closed_delegate _ds6;
+        
+        protected CefJSDialogHandler()
+        {
+            _self = cef_jsdialog_handler_t.Alloc();
+        
+            _ds0 = new cef_jsdialog_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_jsdialog_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_jsdialog_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_jsdialog_handler_t.on_jsdialog_delegate(on_jsdialog);
+            _self->_on_jsdialog = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_jsdialog_handler_t.on_before_unload_dialog_delegate(on_before_unload_dialog);
+            _self->_on_before_unload_dialog = Marshal.GetFunctionPointerForDelegate(_ds4);
+            _ds5 = new cef_jsdialog_handler_t.on_reset_dialog_state_delegate(on_reset_dialog_state);
+            _self->_on_reset_dialog_state = Marshal.GetFunctionPointerForDelegate(_ds5);
+            _ds6 = new cef_jsdialog_handler_t.on_dialog_closed_delegate(on_dialog_closed);
+            _self->_on_dialog_closed = Marshal.GetFunctionPointerForDelegate(_ds6);
+        }
+        
+        ~CefJSDialogHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_jsdialog_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_jsdialog_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_jsdialog_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_jsdialog_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_jsdialog_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_jsdialog_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefKeyboardHandler.g.cs

@@ -0,0 +1,102 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefKeyboardHandler
+    {
+        private static Dictionary<IntPtr, CefKeyboardHandler> _roots = new Dictionary<IntPtr, CefKeyboardHandler>();
+        
+        private int _refct;
+        private cef_keyboard_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_keyboard_handler_t.add_ref_delegate _ds0;
+        private cef_keyboard_handler_t.release_delegate _ds1;
+        private cef_keyboard_handler_t.has_one_ref_delegate _ds2;
+        private cef_keyboard_handler_t.on_pre_key_event_delegate _ds3;
+        private cef_keyboard_handler_t.on_key_event_delegate _ds4;
+        
+        protected CefKeyboardHandler()
+        {
+            _self = cef_keyboard_handler_t.Alloc();
+        
+            _ds0 = new cef_keyboard_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_keyboard_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_keyboard_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_keyboard_handler_t.on_pre_key_event_delegate(on_pre_key_event);
+            _self->_on_pre_key_event = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_keyboard_handler_t.on_key_event_delegate(on_key_event);
+            _self->_on_key_event = Marshal.GetFunctionPointerForDelegate(_ds4);
+        }
+        
+        ~CefKeyboardHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_keyboard_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_keyboard_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_keyboard_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_keyboard_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_keyboard_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_keyboard_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefLifeSpanHandler.g.cs

@@ -0,0 +1,111 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefLifeSpanHandler
+    {
+        private static Dictionary<IntPtr, CefLifeSpanHandler> _roots = new Dictionary<IntPtr, CefLifeSpanHandler>();
+        
+        private int _refct;
+        private cef_life_span_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_life_span_handler_t.add_ref_delegate _ds0;
+        private cef_life_span_handler_t.release_delegate _ds1;
+        private cef_life_span_handler_t.has_one_ref_delegate _ds2;
+        private cef_life_span_handler_t.on_before_popup_delegate _ds3;
+        private cef_life_span_handler_t.on_after_created_delegate _ds4;
+        private cef_life_span_handler_t.run_modal_delegate _ds5;
+        private cef_life_span_handler_t.do_close_delegate _ds6;
+        private cef_life_span_handler_t.on_before_close_delegate _ds7;
+        
+        protected CefLifeSpanHandler()
+        {
+            _self = cef_life_span_handler_t.Alloc();
+        
+            _ds0 = new cef_life_span_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_life_span_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_life_span_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_life_span_handler_t.on_before_popup_delegate(on_before_popup);
+            _self->_on_before_popup = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_life_span_handler_t.on_after_created_delegate(on_after_created);
+            _self->_on_after_created = Marshal.GetFunctionPointerForDelegate(_ds4);
+            _ds5 = new cef_life_span_handler_t.run_modal_delegate(run_modal);
+            _self->_run_modal = Marshal.GetFunctionPointerForDelegate(_ds5);
+            _ds6 = new cef_life_span_handler_t.do_close_delegate(do_close);
+            _self->_do_close = Marshal.GetFunctionPointerForDelegate(_ds6);
+            _ds7 = new cef_life_span_handler_t.on_before_close_delegate(on_before_close);
+            _self->_on_before_close = Marshal.GetFunctionPointerForDelegate(_ds7);
+        }
+        
+        ~CefLifeSpanHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_life_span_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_life_span_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_life_span_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_life_span_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_life_span_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_life_span_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefListValue.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefListValue : IDisposable
+    {
+        internal static CefListValue FromNative(cef_list_value_t* ptr)
+        {
+            return new CefListValue(ptr);
+        }
+        
+        internal static CefListValue FromNativeOrNull(cef_list_value_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefListValue(ptr);
+        }
+        
+        private cef_list_value_t* _self;
+        
+        private CefListValue(cef_list_value_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefListValue()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_list_value_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_list_value_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_list_value_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_list_value_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefLoadHandler.g.cs

@@ -0,0 +1,108 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefLoadHandler
+    {
+        private static Dictionary<IntPtr, CefLoadHandler> _roots = new Dictionary<IntPtr, CefLoadHandler>();
+        
+        private int _refct;
+        private cef_load_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_load_handler_t.add_ref_delegate _ds0;
+        private cef_load_handler_t.release_delegate _ds1;
+        private cef_load_handler_t.has_one_ref_delegate _ds2;
+        private cef_load_handler_t.on_loading_state_change_delegate _ds3;
+        private cef_load_handler_t.on_load_start_delegate _ds4;
+        private cef_load_handler_t.on_load_end_delegate _ds5;
+        private cef_load_handler_t.on_load_error_delegate _ds6;
+        
+        protected CefLoadHandler()
+        {
+            _self = cef_load_handler_t.Alloc();
+        
+            _ds0 = new cef_load_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_load_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_load_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_load_handler_t.on_loading_state_change_delegate(on_loading_state_change);
+            _self->_on_loading_state_change = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_load_handler_t.on_load_start_delegate(on_load_start);
+            _self->_on_load_start = Marshal.GetFunctionPointerForDelegate(_ds4);
+            _ds5 = new cef_load_handler_t.on_load_end_delegate(on_load_end);
+            _self->_on_load_end = Marshal.GetFunctionPointerForDelegate(_ds5);
+            _ds6 = new cef_load_handler_t.on_load_error_delegate(on_load_error);
+            _self->_on_load_error = Marshal.GetFunctionPointerForDelegate(_ds6);
+        }
+        
+        ~CefLoadHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_load_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_load_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_load_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_load_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_load_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_load_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefMenuModel.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefMenuModel : IDisposable
+    {
+        internal static CefMenuModel FromNative(cef_menu_model_t* ptr)
+        {
+            return new CefMenuModel(ptr);
+        }
+        
+        internal static CefMenuModel FromNativeOrNull(cef_menu_model_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefMenuModel(ptr);
+        }
+        
+        private cef_menu_model_t* _self;
+        
+        private CefMenuModel(cef_menu_model_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefMenuModel()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_menu_model_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_menu_model_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_menu_model_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_menu_model_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefNavigationEntry.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefNavigationEntry : IDisposable
+    {
+        internal static CefNavigationEntry FromNative(cef_navigation_entry_t* ptr)
+        {
+            return new CefNavigationEntry(ptr);
+        }
+        
+        internal static CefNavigationEntry FromNativeOrNull(cef_navigation_entry_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefNavigationEntry(ptr);
+        }
+        
+        private cef_navigation_entry_t* _self;
+        
+        private CefNavigationEntry(cef_navigation_entry_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefNavigationEntry()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_navigation_entry_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_navigation_entry_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_navigation_entry_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_navigation_entry_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefNavigationEntryVisitor.g.cs

@@ -0,0 +1,99 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefNavigationEntryVisitor
+    {
+        private static Dictionary<IntPtr, CefNavigationEntryVisitor> _roots = new Dictionary<IntPtr, CefNavigationEntryVisitor>();
+        
+        private int _refct;
+        private cef_navigation_entry_visitor_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_navigation_entry_visitor_t.add_ref_delegate _ds0;
+        private cef_navigation_entry_visitor_t.release_delegate _ds1;
+        private cef_navigation_entry_visitor_t.has_one_ref_delegate _ds2;
+        private cef_navigation_entry_visitor_t.visit_delegate _ds3;
+        
+        protected CefNavigationEntryVisitor()
+        {
+            _self = cef_navigation_entry_visitor_t.Alloc();
+        
+            _ds0 = new cef_navigation_entry_visitor_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_navigation_entry_visitor_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_navigation_entry_visitor_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_navigation_entry_visitor_t.visit_delegate(visit);
+            _self->_visit = Marshal.GetFunctionPointerForDelegate(_ds3);
+        }
+        
+        ~CefNavigationEntryVisitor()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_navigation_entry_visitor_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_navigation_entry_visitor_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_navigation_entry_visitor_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_navigation_entry_visitor_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_navigation_entry_visitor_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_navigation_entry_visitor_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefPdfPrintCallback.g.cs

@@ -0,0 +1,99 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefPdfPrintCallback
+    {
+        private static Dictionary<IntPtr, CefPdfPrintCallback> _roots = new Dictionary<IntPtr, CefPdfPrintCallback>();
+        
+        private int _refct;
+        private cef_pdf_print_callback_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_pdf_print_callback_t.add_ref_delegate _ds0;
+        private cef_pdf_print_callback_t.release_delegate _ds1;
+        private cef_pdf_print_callback_t.has_one_ref_delegate _ds2;
+        private cef_pdf_print_callback_t.on_pdf_print_finished_delegate _ds3;
+        
+        protected CefPdfPrintCallback()
+        {
+            _self = cef_pdf_print_callback_t.Alloc();
+        
+            _ds0 = new cef_pdf_print_callback_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_pdf_print_callback_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_pdf_print_callback_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_pdf_print_callback_t.on_pdf_print_finished_delegate(on_pdf_print_finished);
+            _self->_on_pdf_print_finished = Marshal.GetFunctionPointerForDelegate(_ds3);
+        }
+        
+        ~CefPdfPrintCallback()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_pdf_print_callback_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_pdf_print_callback_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_pdf_print_callback_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_pdf_print_callback_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_pdf_print_callback_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_pdf_print_callback_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefPostData.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefPostData : IDisposable
+    {
+        internal static CefPostData FromNative(cef_post_data_t* ptr)
+        {
+            return new CefPostData(ptr);
+        }
+        
+        internal static CefPostData FromNativeOrNull(cef_post_data_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefPostData(ptr);
+        }
+        
+        private cef_post_data_t* _self;
+        
+        private CefPostData(cef_post_data_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefPostData()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_post_data_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_post_data_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_post_data_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_post_data_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefPostDataElement.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefPostDataElement : IDisposable
+    {
+        internal static CefPostDataElement FromNative(cef_post_data_element_t* ptr)
+        {
+            return new CefPostDataElement(ptr);
+        }
+        
+        internal static CefPostDataElement FromNativeOrNull(cef_post_data_element_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefPostDataElement(ptr);
+        }
+        
+        private cef_post_data_element_t* _self;
+        
+        private CefPostDataElement(cef_post_data_element_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefPostDataElement()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_post_data_element_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_post_data_element_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_post_data_element_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_post_data_element_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefPrintDialogCallback.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefPrintDialogCallback : IDisposable
+    {
+        internal static CefPrintDialogCallback FromNative(cef_print_dialog_callback_t* ptr)
+        {
+            return new CefPrintDialogCallback(ptr);
+        }
+        
+        internal static CefPrintDialogCallback FromNativeOrNull(cef_print_dialog_callback_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefPrintDialogCallback(ptr);
+        }
+        
+        private cef_print_dialog_callback_t* _self;
+        
+        private CefPrintDialogCallback(cef_print_dialog_callback_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefPrintDialogCallback()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_print_dialog_callback_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_print_dialog_callback_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_print_dialog_callback_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_print_dialog_callback_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefPrintHandler.g.cs

@@ -0,0 +1,111 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefPrintHandler
+    {
+        private static Dictionary<IntPtr, CefPrintHandler> _roots = new Dictionary<IntPtr, CefPrintHandler>();
+        
+        private int _refct;
+        private cef_print_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_print_handler_t.add_ref_delegate _ds0;
+        private cef_print_handler_t.release_delegate _ds1;
+        private cef_print_handler_t.has_one_ref_delegate _ds2;
+        private cef_print_handler_t.on_print_settings_delegate _ds3;
+        private cef_print_handler_t.on_print_dialog_delegate _ds4;
+        private cef_print_handler_t.on_print_job_delegate _ds5;
+        private cef_print_handler_t.on_print_reset_delegate _ds6;
+        private cef_print_handler_t.get_pdf_paper_size_delegate _ds7;
+        
+        protected CefPrintHandler()
+        {
+            _self = cef_print_handler_t.Alloc();
+        
+            _ds0 = new cef_print_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_print_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_print_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_print_handler_t.on_print_settings_delegate(on_print_settings);
+            _self->_on_print_settings = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_print_handler_t.on_print_dialog_delegate(on_print_dialog);
+            _self->_on_print_dialog = Marshal.GetFunctionPointerForDelegate(_ds4);
+            _ds5 = new cef_print_handler_t.on_print_job_delegate(on_print_job);
+            _self->_on_print_job = Marshal.GetFunctionPointerForDelegate(_ds5);
+            _ds6 = new cef_print_handler_t.on_print_reset_delegate(on_print_reset);
+            _self->_on_print_reset = Marshal.GetFunctionPointerForDelegate(_ds6);
+            _ds7 = new cef_print_handler_t.get_pdf_paper_size_delegate(get_pdf_paper_size);
+            _self->_get_pdf_paper_size = Marshal.GetFunctionPointerForDelegate(_ds7);
+        }
+        
+        ~CefPrintHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_print_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_print_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_print_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_print_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_print_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_print_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefPrintJobCallback.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefPrintJobCallback : IDisposable
+    {
+        internal static CefPrintJobCallback FromNative(cef_print_job_callback_t* ptr)
+        {
+            return new CefPrintJobCallback(ptr);
+        }
+        
+        internal static CefPrintJobCallback FromNativeOrNull(cef_print_job_callback_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefPrintJobCallback(ptr);
+        }
+        
+        private cef_print_job_callback_t* _self;
+        
+        private CefPrintJobCallback(cef_print_job_callback_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefPrintJobCallback()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_print_job_callback_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_print_job_callback_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_print_job_callback_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_print_job_callback_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefPrintSettings.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefPrintSettings : IDisposable
+    {
+        internal static CefPrintSettings FromNative(cef_print_settings_t* ptr)
+        {
+            return new CefPrintSettings(ptr);
+        }
+        
+        internal static CefPrintSettings FromNativeOrNull(cef_print_settings_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefPrintSettings(ptr);
+        }
+        
+        private cef_print_settings_t* _self;
+        
+        private CefPrintSettings(cef_print_settings_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefPrintSettings()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_print_settings_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_print_settings_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_print_settings_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_print_settings_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefProcessMessage.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefProcessMessage : IDisposable
+    {
+        internal static CefProcessMessage FromNative(cef_process_message_t* ptr)
+        {
+            return new CefProcessMessage(ptr);
+        }
+        
+        internal static CefProcessMessage FromNativeOrNull(cef_process_message_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefProcessMessage(ptr);
+        }
+        
+        private cef_process_message_t* _self;
+        
+        private CefProcessMessage(cef_process_message_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefProcessMessage()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_process_message_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_process_message_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_process_message_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_process_message_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefReadHandler.g.cs

@@ -0,0 +1,111 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefReadHandler
+    {
+        private static Dictionary<IntPtr, CefReadHandler> _roots = new Dictionary<IntPtr, CefReadHandler>();
+        
+        private int _refct;
+        private cef_read_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_read_handler_t.add_ref_delegate _ds0;
+        private cef_read_handler_t.release_delegate _ds1;
+        private cef_read_handler_t.has_one_ref_delegate _ds2;
+        private cef_read_handler_t.read_delegate _ds3;
+        private cef_read_handler_t.seek_delegate _ds4;
+        private cef_read_handler_t.tell_delegate _ds5;
+        private cef_read_handler_t.eof_delegate _ds6;
+        private cef_read_handler_t.may_block_delegate _ds7;
+        
+        protected CefReadHandler()
+        {
+            _self = cef_read_handler_t.Alloc();
+        
+            _ds0 = new cef_read_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_read_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_read_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_read_handler_t.read_delegate(read);
+            _self->_read = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_read_handler_t.seek_delegate(seek);
+            _self->_seek = Marshal.GetFunctionPointerForDelegate(_ds4);
+            _ds5 = new cef_read_handler_t.tell_delegate(tell);
+            _self->_tell = Marshal.GetFunctionPointerForDelegate(_ds5);
+            _ds6 = new cef_read_handler_t.eof_delegate(eof);
+            _self->_eof = Marshal.GetFunctionPointerForDelegate(_ds6);
+            _ds7 = new cef_read_handler_t.may_block_delegate(may_block);
+            _self->_may_block = Marshal.GetFunctionPointerForDelegate(_ds7);
+        }
+        
+        ~CefReadHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_read_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_read_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_read_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_read_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_read_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_read_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefRenderHandler.g.cs

@@ -0,0 +1,129 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefRenderHandler
+    {
+        private static Dictionary<IntPtr, CefRenderHandler> _roots = new Dictionary<IntPtr, CefRenderHandler>();
+        
+        private int _refct;
+        private cef_render_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_render_handler_t.add_ref_delegate _ds0;
+        private cef_render_handler_t.release_delegate _ds1;
+        private cef_render_handler_t.has_one_ref_delegate _ds2;
+        private cef_render_handler_t.get_root_screen_rect_delegate _ds3;
+        private cef_render_handler_t.get_view_rect_delegate _ds4;
+        private cef_render_handler_t.get_screen_point_delegate _ds5;
+        private cef_render_handler_t.get_screen_info_delegate _ds6;
+        private cef_render_handler_t.on_popup_show_delegate _ds7;
+        private cef_render_handler_t.on_popup_size_delegate _ds8;
+        private cef_render_handler_t.on_paint_delegate _ds9;
+        private cef_render_handler_t.on_cursor_change_delegate _dsa;
+        private cef_render_handler_t.start_dragging_delegate _dsb;
+        private cef_render_handler_t.update_drag_cursor_delegate _dsc;
+        private cef_render_handler_t.on_scroll_offset_changed_delegate _dsd;
+        
+        protected CefRenderHandler()
+        {
+            _self = cef_render_handler_t.Alloc();
+        
+            _ds0 = new cef_render_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_render_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_render_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_render_handler_t.get_root_screen_rect_delegate(get_root_screen_rect);
+            _self->_get_root_screen_rect = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_render_handler_t.get_view_rect_delegate(get_view_rect);
+            _self->_get_view_rect = Marshal.GetFunctionPointerForDelegate(_ds4);
+            _ds5 = new cef_render_handler_t.get_screen_point_delegate(get_screen_point);
+            _self->_get_screen_point = Marshal.GetFunctionPointerForDelegate(_ds5);
+            _ds6 = new cef_render_handler_t.get_screen_info_delegate(get_screen_info);
+            _self->_get_screen_info = Marshal.GetFunctionPointerForDelegate(_ds6);
+            _ds7 = new cef_render_handler_t.on_popup_show_delegate(on_popup_show);
+            _self->_on_popup_show = Marshal.GetFunctionPointerForDelegate(_ds7);
+            _ds8 = new cef_render_handler_t.on_popup_size_delegate(on_popup_size);
+            _self->_on_popup_size = Marshal.GetFunctionPointerForDelegate(_ds8);
+            _ds9 = new cef_render_handler_t.on_paint_delegate(on_paint);
+            _self->_on_paint = Marshal.GetFunctionPointerForDelegate(_ds9);
+            _dsa = new cef_render_handler_t.on_cursor_change_delegate(on_cursor_change);
+            _self->_on_cursor_change = Marshal.GetFunctionPointerForDelegate(_dsa);
+            _dsb = new cef_render_handler_t.start_dragging_delegate(start_dragging);
+            _self->_start_dragging = Marshal.GetFunctionPointerForDelegate(_dsb);
+            _dsc = new cef_render_handler_t.update_drag_cursor_delegate(update_drag_cursor);
+            _self->_update_drag_cursor = Marshal.GetFunctionPointerForDelegate(_dsc);
+            _dsd = new cef_render_handler_t.on_scroll_offset_changed_delegate(on_scroll_offset_changed);
+            _self->_on_scroll_offset_changed = Marshal.GetFunctionPointerForDelegate(_dsd);
+        }
+        
+        ~CefRenderHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_render_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_render_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_render_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_render_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_render_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_render_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefRenderProcessHandler.g.cs

@@ -0,0 +1,129 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefRenderProcessHandler
+    {
+        private static Dictionary<IntPtr, CefRenderProcessHandler> _roots = new Dictionary<IntPtr, CefRenderProcessHandler>();
+        
+        private int _refct;
+        private cef_render_process_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_render_process_handler_t.add_ref_delegate _ds0;
+        private cef_render_process_handler_t.release_delegate _ds1;
+        private cef_render_process_handler_t.has_one_ref_delegate _ds2;
+        private cef_render_process_handler_t.on_render_thread_created_delegate _ds3;
+        private cef_render_process_handler_t.on_web_kit_initialized_delegate _ds4;
+        private cef_render_process_handler_t.on_browser_created_delegate _ds5;
+        private cef_render_process_handler_t.on_browser_destroyed_delegate _ds6;
+        private cef_render_process_handler_t.get_load_handler_delegate _ds7;
+        private cef_render_process_handler_t.on_before_navigation_delegate _ds8;
+        private cef_render_process_handler_t.on_context_created_delegate _ds9;
+        private cef_render_process_handler_t.on_context_released_delegate _dsa;
+        private cef_render_process_handler_t.on_uncaught_exception_delegate _dsb;
+        private cef_render_process_handler_t.on_focused_node_changed_delegate _dsc;
+        private cef_render_process_handler_t.on_process_message_received_delegate _dsd;
+        
+        protected CefRenderProcessHandler()
+        {
+            _self = cef_render_process_handler_t.Alloc();
+        
+            _ds0 = new cef_render_process_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_render_process_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_render_process_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_render_process_handler_t.on_render_thread_created_delegate(on_render_thread_created);
+            _self->_on_render_thread_created = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_render_process_handler_t.on_web_kit_initialized_delegate(on_web_kit_initialized);
+            _self->_on_web_kit_initialized = Marshal.GetFunctionPointerForDelegate(_ds4);
+            _ds5 = new cef_render_process_handler_t.on_browser_created_delegate(on_browser_created);
+            _self->_on_browser_created = Marshal.GetFunctionPointerForDelegate(_ds5);
+            _ds6 = new cef_render_process_handler_t.on_browser_destroyed_delegate(on_browser_destroyed);
+            _self->_on_browser_destroyed = Marshal.GetFunctionPointerForDelegate(_ds6);
+            _ds7 = new cef_render_process_handler_t.get_load_handler_delegate(get_load_handler);
+            _self->_get_load_handler = Marshal.GetFunctionPointerForDelegate(_ds7);
+            _ds8 = new cef_render_process_handler_t.on_before_navigation_delegate(on_before_navigation);
+            _self->_on_before_navigation = Marshal.GetFunctionPointerForDelegate(_ds8);
+            _ds9 = new cef_render_process_handler_t.on_context_created_delegate(on_context_created);
+            _self->_on_context_created = Marshal.GetFunctionPointerForDelegate(_ds9);
+            _dsa = new cef_render_process_handler_t.on_context_released_delegate(on_context_released);
+            _self->_on_context_released = Marshal.GetFunctionPointerForDelegate(_dsa);
+            _dsb = new cef_render_process_handler_t.on_uncaught_exception_delegate(on_uncaught_exception);
+            _self->_on_uncaught_exception = Marshal.GetFunctionPointerForDelegate(_dsb);
+            _dsc = new cef_render_process_handler_t.on_focused_node_changed_delegate(on_focused_node_changed);
+            _self->_on_focused_node_changed = Marshal.GetFunctionPointerForDelegate(_dsc);
+            _dsd = new cef_render_process_handler_t.on_process_message_received_delegate(on_process_message_received);
+            _self->_on_process_message_received = Marshal.GetFunctionPointerForDelegate(_dsd);
+        }
+        
+        ~CefRenderProcessHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_render_process_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_render_process_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_render_process_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_render_process_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_render_process_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_render_process_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefRequest.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefRequest : IDisposable
+    {
+        internal static CefRequest FromNative(cef_request_t* ptr)
+        {
+            return new CefRequest(ptr);
+        }
+        
+        internal static CefRequest FromNativeOrNull(cef_request_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefRequest(ptr);
+        }
+        
+        private cef_request_t* _self;
+        
+        private CefRequest(cef_request_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefRequest()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_request_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_request_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_request_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_request_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefRequestCallback.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefRequestCallback : IDisposable
+    {
+        internal static CefRequestCallback FromNative(cef_request_callback_t* ptr)
+        {
+            return new CefRequestCallback(ptr);
+        }
+        
+        internal static CefRequestCallback FromNativeOrNull(cef_request_callback_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefRequestCallback(ptr);
+        }
+        
+        private cef_request_callback_t* _self;
+        
+        private CefRequestCallback(cef_request_callback_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefRequestCallback()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_request_callback_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_request_callback_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_request_callback_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_request_callback_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefRequestContext.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefRequestContext : IDisposable
+    {
+        internal static CefRequestContext FromNative(cef_request_context_t* ptr)
+        {
+            return new CefRequestContext(ptr);
+        }
+        
+        internal static CefRequestContext FromNativeOrNull(cef_request_context_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefRequestContext(ptr);
+        }
+        
+        private cef_request_context_t* _self;
+        
+        private CefRequestContext(cef_request_context_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefRequestContext()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_request_context_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_request_context_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_request_context_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_request_context_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefRequestContextHandler.g.cs

@@ -0,0 +1,117 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefRequestContextHandler
+    {
+        private static Dictionary<IntPtr, CefRequestContextHandler> _roots = new Dictionary<IntPtr, CefRequestContextHandler>();
+        
+        private int _refct;
+        private cef_request_context_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        internal static CefRequestContextHandler FromNativeOrNull(cef_request_context_handler_t* ptr)
+        {
+            CefRequestContextHandler value = null;
+            bool found;
+            lock (_roots)
+            {
+                found = _roots.TryGetValue((IntPtr)ptr, out value);
+            }
+            return found ? value : null;
+        }
+        
+        internal static CefRequestContextHandler FromNative(cef_request_context_handler_t* ptr)
+        {
+            var value = FromNativeOrNull(ptr);
+            if (value == null) throw ExceptionBuilder.ObjectNotFound();
+            return value;
+        }
+        
+        private cef_request_context_handler_t.add_ref_delegate _ds0;
+        private cef_request_context_handler_t.release_delegate _ds1;
+        private cef_request_context_handler_t.has_one_ref_delegate _ds2;
+        private cef_request_context_handler_t.get_cookie_manager_delegate _ds3;
+        
+        protected CefRequestContextHandler()
+        {
+            _self = cef_request_context_handler_t.Alloc();
+        
+            _ds0 = new cef_request_context_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_request_context_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_request_context_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_request_context_handler_t.get_cookie_manager_delegate(get_cookie_manager);
+            _self->_get_cookie_manager = Marshal.GetFunctionPointerForDelegate(_ds3);
+        }
+        
+        ~CefRequestContextHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_request_context_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_request_context_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_request_context_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_request_context_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_request_context_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_request_context_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefRequestHandler.g.cs

@@ -0,0 +1,138 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefRequestHandler
+    {
+        private static Dictionary<IntPtr, CefRequestHandler> _roots = new Dictionary<IntPtr, CefRequestHandler>();
+        
+        private int _refct;
+        private cef_request_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_request_handler_t.add_ref_delegate _ds0;
+        private cef_request_handler_t.release_delegate _ds1;
+        private cef_request_handler_t.has_one_ref_delegate _ds2;
+        private cef_request_handler_t.on_before_browse_delegate _ds3;
+        private cef_request_handler_t.on_open_urlfrom_tab_delegate _ds4;
+        private cef_request_handler_t.on_before_resource_load_delegate _ds5;
+        private cef_request_handler_t.get_resource_handler_delegate _ds6;
+        private cef_request_handler_t.on_resource_redirect_delegate _ds7;
+        private cef_request_handler_t.on_resource_response_delegate _ds8;
+        private cef_request_handler_t.get_auth_credentials_delegate _ds9;
+        private cef_request_handler_t.on_quota_request_delegate _dsa;
+        private cef_request_handler_t.on_protocol_execution_delegate _dsb;
+        private cef_request_handler_t.on_certificate_error_delegate _dsc;
+        private cef_request_handler_t.on_before_plugin_load_delegate _dsd;
+        private cef_request_handler_t.on_plugin_crashed_delegate _dse;
+        private cef_request_handler_t.on_render_view_ready_delegate _dsf;
+        private cef_request_handler_t.on_render_process_terminated_delegate _ds10;
+        
+        protected CefRequestHandler()
+        {
+            _self = cef_request_handler_t.Alloc();
+        
+            _ds0 = new cef_request_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_request_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_request_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_request_handler_t.on_before_browse_delegate(on_before_browse);
+            _self->_on_before_browse = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_request_handler_t.on_open_urlfrom_tab_delegate(on_open_urlfrom_tab);
+            _self->_on_open_urlfrom_tab = Marshal.GetFunctionPointerForDelegate(_ds4);
+            _ds5 = new cef_request_handler_t.on_before_resource_load_delegate(on_before_resource_load);
+            _self->_on_before_resource_load = Marshal.GetFunctionPointerForDelegate(_ds5);
+            _ds6 = new cef_request_handler_t.get_resource_handler_delegate(get_resource_handler);
+            _self->_get_resource_handler = Marshal.GetFunctionPointerForDelegate(_ds6);
+            _ds7 = new cef_request_handler_t.on_resource_redirect_delegate(on_resource_redirect);
+            _self->_on_resource_redirect = Marshal.GetFunctionPointerForDelegate(_ds7);
+            _ds8 = new cef_request_handler_t.on_resource_response_delegate(on_resource_response);
+            _self->_on_resource_response = Marshal.GetFunctionPointerForDelegate(_ds8);
+            _ds9 = new cef_request_handler_t.get_auth_credentials_delegate(get_auth_credentials);
+            _self->_get_auth_credentials = Marshal.GetFunctionPointerForDelegate(_ds9);
+            _dsa = new cef_request_handler_t.on_quota_request_delegate(on_quota_request);
+            _self->_on_quota_request = Marshal.GetFunctionPointerForDelegate(_dsa);
+            _dsb = new cef_request_handler_t.on_protocol_execution_delegate(on_protocol_execution);
+            _self->_on_protocol_execution = Marshal.GetFunctionPointerForDelegate(_dsb);
+            _dsc = new cef_request_handler_t.on_certificate_error_delegate(on_certificate_error);
+            _self->_on_certificate_error = Marshal.GetFunctionPointerForDelegate(_dsc);
+            _dsd = new cef_request_handler_t.on_before_plugin_load_delegate(on_before_plugin_load);
+            _self->_on_before_plugin_load = Marshal.GetFunctionPointerForDelegate(_dsd);
+            _dse = new cef_request_handler_t.on_plugin_crashed_delegate(on_plugin_crashed);
+            _self->_on_plugin_crashed = Marshal.GetFunctionPointerForDelegate(_dse);
+            _dsf = new cef_request_handler_t.on_render_view_ready_delegate(on_render_view_ready);
+            _self->_on_render_view_ready = Marshal.GetFunctionPointerForDelegate(_dsf);
+            _ds10 = new cef_request_handler_t.on_render_process_terminated_delegate(on_render_process_terminated);
+            _self->_on_render_process_terminated = Marshal.GetFunctionPointerForDelegate(_ds10);
+        }
+        
+        ~CefRequestHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_request_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_request_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_request_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_request_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_request_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_request_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefResourceBundleHandler.g.cs

@@ -0,0 +1,102 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefResourceBundleHandler
+    {
+        private static Dictionary<IntPtr, CefResourceBundleHandler> _roots = new Dictionary<IntPtr, CefResourceBundleHandler>();
+        
+        private int _refct;
+        private cef_resource_bundle_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_resource_bundle_handler_t.add_ref_delegate _ds0;
+        private cef_resource_bundle_handler_t.release_delegate _ds1;
+        private cef_resource_bundle_handler_t.has_one_ref_delegate _ds2;
+        private cef_resource_bundle_handler_t.get_localized_string_delegate _ds3;
+        private cef_resource_bundle_handler_t.get_data_resource_delegate _ds4;
+        
+        protected CefResourceBundleHandler()
+        {
+            _self = cef_resource_bundle_handler_t.Alloc();
+        
+            _ds0 = new cef_resource_bundle_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_resource_bundle_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_resource_bundle_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_resource_bundle_handler_t.get_localized_string_delegate(get_localized_string);
+            _self->_get_localized_string = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_resource_bundle_handler_t.get_data_resource_delegate(get_data_resource);
+            _self->_get_data_resource = Marshal.GetFunctionPointerForDelegate(_ds4);
+        }
+        
+        ~CefResourceBundleHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_resource_bundle_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_resource_bundle_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_resource_bundle_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_resource_bundle_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_resource_bundle_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_resource_bundle_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefResourceHandler.g.cs

@@ -0,0 +1,114 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefResourceHandler
+    {
+        private static Dictionary<IntPtr, CefResourceHandler> _roots = new Dictionary<IntPtr, CefResourceHandler>();
+        
+        private int _refct;
+        private cef_resource_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_resource_handler_t.add_ref_delegate _ds0;
+        private cef_resource_handler_t.release_delegate _ds1;
+        private cef_resource_handler_t.has_one_ref_delegate _ds2;
+        private cef_resource_handler_t.process_request_delegate _ds3;
+        private cef_resource_handler_t.get_response_headers_delegate _ds4;
+        private cef_resource_handler_t.read_response_delegate _ds5;
+        private cef_resource_handler_t.can_get_cookie_delegate _ds6;
+        private cef_resource_handler_t.can_set_cookie_delegate _ds7;
+        private cef_resource_handler_t.cancel_delegate _ds8;
+        
+        protected CefResourceHandler()
+        {
+            _self = cef_resource_handler_t.Alloc();
+        
+            _ds0 = new cef_resource_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_resource_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_resource_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_resource_handler_t.process_request_delegate(process_request);
+            _self->_process_request = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_resource_handler_t.get_response_headers_delegate(get_response_headers);
+            _self->_get_response_headers = Marshal.GetFunctionPointerForDelegate(_ds4);
+            _ds5 = new cef_resource_handler_t.read_response_delegate(read_response);
+            _self->_read_response = Marshal.GetFunctionPointerForDelegate(_ds5);
+            _ds6 = new cef_resource_handler_t.can_get_cookie_delegate(can_get_cookie);
+            _self->_can_get_cookie = Marshal.GetFunctionPointerForDelegate(_ds6);
+            _ds7 = new cef_resource_handler_t.can_set_cookie_delegate(can_set_cookie);
+            _self->_can_set_cookie = Marshal.GetFunctionPointerForDelegate(_ds7);
+            _ds8 = new cef_resource_handler_t.cancel_delegate(cancel);
+            _self->_cancel = Marshal.GetFunctionPointerForDelegate(_ds8);
+        }
+        
+        ~CefResourceHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_resource_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_resource_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_resource_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_resource_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_resource_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_resource_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefResponse.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefResponse : IDisposable
+    {
+        internal static CefResponse FromNative(cef_response_t* ptr)
+        {
+            return new CefResponse(ptr);
+        }
+        
+        internal static CefResponse FromNativeOrNull(cef_response_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefResponse(ptr);
+        }
+        
+        private cef_response_t* _self;
+        
+        private CefResponse(cef_response_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefResponse()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_response_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_response_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_response_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_response_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefRunFileDialogCallback.g.cs

@@ -0,0 +1,99 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefRunFileDialogCallback
+    {
+        private static Dictionary<IntPtr, CefRunFileDialogCallback> _roots = new Dictionary<IntPtr, CefRunFileDialogCallback>();
+        
+        private int _refct;
+        private cef_run_file_dialog_callback_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_run_file_dialog_callback_t.add_ref_delegate _ds0;
+        private cef_run_file_dialog_callback_t.release_delegate _ds1;
+        private cef_run_file_dialog_callback_t.has_one_ref_delegate _ds2;
+        private cef_run_file_dialog_callback_t.on_file_dialog_dismissed_delegate _ds3;
+        
+        protected CefRunFileDialogCallback()
+        {
+            _self = cef_run_file_dialog_callback_t.Alloc();
+        
+            _ds0 = new cef_run_file_dialog_callback_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_run_file_dialog_callback_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_run_file_dialog_callback_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_run_file_dialog_callback_t.on_file_dialog_dismissed_delegate(on_file_dialog_dismissed);
+            _self->_on_file_dialog_dismissed = Marshal.GetFunctionPointerForDelegate(_ds3);
+        }
+        
+        ~CefRunFileDialogCallback()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_run_file_dialog_callback_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_run_file_dialog_callback_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_run_file_dialog_callback_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_run_file_dialog_callback_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_run_file_dialog_callback_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_run_file_dialog_callback_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefSchemeHandlerFactory.g.cs

@@ -0,0 +1,99 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefSchemeHandlerFactory
+    {
+        private static Dictionary<IntPtr, CefSchemeHandlerFactory> _roots = new Dictionary<IntPtr, CefSchemeHandlerFactory>();
+        
+        private int _refct;
+        private cef_scheme_handler_factory_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_scheme_handler_factory_t.add_ref_delegate _ds0;
+        private cef_scheme_handler_factory_t.release_delegate _ds1;
+        private cef_scheme_handler_factory_t.has_one_ref_delegate _ds2;
+        private cef_scheme_handler_factory_t.create_delegate _ds3;
+        
+        protected CefSchemeHandlerFactory()
+        {
+            _self = cef_scheme_handler_factory_t.Alloc();
+        
+            _ds0 = new cef_scheme_handler_factory_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_scheme_handler_factory_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_scheme_handler_factory_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_scheme_handler_factory_t.create_delegate(create);
+            _self->_create = Marshal.GetFunctionPointerForDelegate(_ds3);
+        }
+        
+        ~CefSchemeHandlerFactory()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_scheme_handler_factory_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_scheme_handler_factory_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_scheme_handler_factory_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_scheme_handler_factory_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_scheme_handler_factory_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_scheme_handler_factory_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefSchemeRegistrar.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefSchemeRegistrar : IDisposable
+    {
+        internal static CefSchemeRegistrar FromNative(cef_scheme_registrar_t* ptr)
+        {
+            return new CefSchemeRegistrar(ptr);
+        }
+        
+        internal static CefSchemeRegistrar FromNativeOrNull(cef_scheme_registrar_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefSchemeRegistrar(ptr);
+        }
+        
+        private cef_scheme_registrar_t* _self;
+        
+        private CefSchemeRegistrar(cef_scheme_registrar_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefSchemeRegistrar()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_scheme_registrar_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_scheme_registrar_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_scheme_registrar_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_scheme_registrar_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefSetCookieCallback.g.cs

@@ -0,0 +1,99 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefSetCookieCallback
+    {
+        private static Dictionary<IntPtr, CefSetCookieCallback> _roots = new Dictionary<IntPtr, CefSetCookieCallback>();
+        
+        private int _refct;
+        private cef_set_cookie_callback_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_set_cookie_callback_t.add_ref_delegate _ds0;
+        private cef_set_cookie_callback_t.release_delegate _ds1;
+        private cef_set_cookie_callback_t.has_one_ref_delegate _ds2;
+        private cef_set_cookie_callback_t.on_complete_delegate _ds3;
+        
+        protected CefSetCookieCallback()
+        {
+            _self = cef_set_cookie_callback_t.Alloc();
+        
+            _ds0 = new cef_set_cookie_callback_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_set_cookie_callback_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_set_cookie_callback_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_set_cookie_callback_t.on_complete_delegate(on_complete);
+            _self->_on_complete = Marshal.GetFunctionPointerForDelegate(_ds3);
+        }
+        
+        ~CefSetCookieCallback()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_set_cookie_callback_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_set_cookie_callback_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_set_cookie_callback_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_set_cookie_callback_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_set_cookie_callback_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_set_cookie_callback_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefSslCertPrincipal.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefSslCertPrincipal : IDisposable
+    {
+        internal static CefSslCertPrincipal FromNative(cef_sslcert_principal_t* ptr)
+        {
+            return new CefSslCertPrincipal(ptr);
+        }
+        
+        internal static CefSslCertPrincipal FromNativeOrNull(cef_sslcert_principal_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefSslCertPrincipal(ptr);
+        }
+        
+        private cef_sslcert_principal_t* _self;
+        
+        private CefSslCertPrincipal(cef_sslcert_principal_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefSslCertPrincipal()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_sslcert_principal_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_sslcert_principal_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_sslcert_principal_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_sslcert_principal_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefSslInfo.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefSslInfo : IDisposable
+    {
+        internal static CefSslInfo FromNative(cef_sslinfo_t* ptr)
+        {
+            return new CefSslInfo(ptr);
+        }
+        
+        internal static CefSslInfo FromNativeOrNull(cef_sslinfo_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefSslInfo(ptr);
+        }
+        
+        private cef_sslinfo_t* _self;
+        
+        private CefSslInfo(cef_sslinfo_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefSslInfo()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_sslinfo_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_sslinfo_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_sslinfo_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_sslinfo_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefStreamReader.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefStreamReader : IDisposable
+    {
+        internal static CefStreamReader FromNative(cef_stream_reader_t* ptr)
+        {
+            return new CefStreamReader(ptr);
+        }
+        
+        internal static CefStreamReader FromNativeOrNull(cef_stream_reader_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefStreamReader(ptr);
+        }
+        
+        private cef_stream_reader_t* _self;
+        
+        private CefStreamReader(cef_stream_reader_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefStreamReader()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_stream_reader_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_stream_reader_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_stream_reader_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_stream_reader_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefStreamWriter.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefStreamWriter : IDisposable
+    {
+        internal static CefStreamWriter FromNative(cef_stream_writer_t* ptr)
+        {
+            return new CefStreamWriter(ptr);
+        }
+        
+        internal static CefStreamWriter FromNativeOrNull(cef_stream_writer_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefStreamWriter(ptr);
+        }
+        
+        private cef_stream_writer_t* _self;
+        
+        private CefStreamWriter(cef_stream_writer_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefStreamWriter()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_stream_writer_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_stream_writer_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_stream_writer_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_stream_writer_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefStringVisitor.g.cs

@@ -0,0 +1,99 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefStringVisitor
+    {
+        private static Dictionary<IntPtr, CefStringVisitor> _roots = new Dictionary<IntPtr, CefStringVisitor>();
+        
+        private int _refct;
+        private cef_string_visitor_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_string_visitor_t.add_ref_delegate _ds0;
+        private cef_string_visitor_t.release_delegate _ds1;
+        private cef_string_visitor_t.has_one_ref_delegate _ds2;
+        private cef_string_visitor_t.visit_delegate _ds3;
+        
+        protected CefStringVisitor()
+        {
+            _self = cef_string_visitor_t.Alloc();
+        
+            _ds0 = new cef_string_visitor_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_string_visitor_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_string_visitor_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_string_visitor_t.visit_delegate(visit);
+            _self->_visit = Marshal.GetFunctionPointerForDelegate(_ds3);
+        }
+        
+        ~CefStringVisitor()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_string_visitor_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_string_visitor_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_string_visitor_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_string_visitor_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_string_visitor_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_string_visitor_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefTask.g.cs

@@ -0,0 +1,99 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefTask
+    {
+        private static Dictionary<IntPtr, CefTask> _roots = new Dictionary<IntPtr, CefTask>();
+        
+        private int _refct;
+        private cef_task_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_task_t.add_ref_delegate _ds0;
+        private cef_task_t.release_delegate _ds1;
+        private cef_task_t.has_one_ref_delegate _ds2;
+        private cef_task_t.execute_delegate _ds3;
+        
+        protected CefTask()
+        {
+            _self = cef_task_t.Alloc();
+        
+            _ds0 = new cef_task_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_task_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_task_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_task_t.execute_delegate(execute);
+            _self->_execute = Marshal.GetFunctionPointerForDelegate(_ds3);
+        }
+        
+        ~CefTask()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_task_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_task_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_task_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_task_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_task_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_task_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefTaskRunner.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefTaskRunner : IDisposable
+    {
+        internal static CefTaskRunner FromNative(cef_task_runner_t* ptr)
+        {
+            return new CefTaskRunner(ptr);
+        }
+        
+        internal static CefTaskRunner FromNativeOrNull(cef_task_runner_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefTaskRunner(ptr);
+        }
+        
+        private cef_task_runner_t* _self;
+        
+        private CefTaskRunner(cef_task_runner_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefTaskRunner()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_task_runner_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_task_runner_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_task_runner_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_task_runner_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefUrlRequest.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefUrlRequest : IDisposable
+    {
+        internal static CefUrlRequest FromNative(cef_urlrequest_t* ptr)
+        {
+            return new CefUrlRequest(ptr);
+        }
+        
+        internal static CefUrlRequest FromNativeOrNull(cef_urlrequest_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefUrlRequest(ptr);
+        }
+        
+        private cef_urlrequest_t* _self;
+        
+        private CefUrlRequest(cef_urlrequest_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefUrlRequest()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_urlrequest_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_urlrequest_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_urlrequest_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_urlrequest_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefUrlRequestClient.g.cs

@@ -0,0 +1,129 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefUrlRequestClient
+    {
+        private static Dictionary<IntPtr, CefUrlRequestClient> _roots = new Dictionary<IntPtr, CefUrlRequestClient>();
+        
+        private int _refct;
+        private cef_urlrequest_client_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        internal static CefUrlRequestClient FromNativeOrNull(cef_urlrequest_client_t* ptr)
+        {
+            CefUrlRequestClient value = null;
+            bool found;
+            lock (_roots)
+            {
+                found = _roots.TryGetValue((IntPtr)ptr, out value);
+            }
+            return found ? value : null;
+        }
+        
+        internal static CefUrlRequestClient FromNative(cef_urlrequest_client_t* ptr)
+        {
+            var value = FromNativeOrNull(ptr);
+            if (value == null) throw ExceptionBuilder.ObjectNotFound();
+            return value;
+        }
+        
+        private cef_urlrequest_client_t.add_ref_delegate _ds0;
+        private cef_urlrequest_client_t.release_delegate _ds1;
+        private cef_urlrequest_client_t.has_one_ref_delegate _ds2;
+        private cef_urlrequest_client_t.on_request_complete_delegate _ds3;
+        private cef_urlrequest_client_t.on_upload_progress_delegate _ds4;
+        private cef_urlrequest_client_t.on_download_progress_delegate _ds5;
+        private cef_urlrequest_client_t.on_download_data_delegate _ds6;
+        private cef_urlrequest_client_t.get_auth_credentials_delegate _ds7;
+        
+        protected CefUrlRequestClient()
+        {
+            _self = cef_urlrequest_client_t.Alloc();
+        
+            _ds0 = new cef_urlrequest_client_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_urlrequest_client_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_urlrequest_client_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_urlrequest_client_t.on_request_complete_delegate(on_request_complete);
+            _self->_on_request_complete = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_urlrequest_client_t.on_upload_progress_delegate(on_upload_progress);
+            _self->_on_upload_progress = Marshal.GetFunctionPointerForDelegate(_ds4);
+            _ds5 = new cef_urlrequest_client_t.on_download_progress_delegate(on_download_progress);
+            _self->_on_download_progress = Marshal.GetFunctionPointerForDelegate(_ds5);
+            _ds6 = new cef_urlrequest_client_t.on_download_data_delegate(on_download_data);
+            _self->_on_download_data = Marshal.GetFunctionPointerForDelegate(_ds6);
+            _ds7 = new cef_urlrequest_client_t.get_auth_credentials_delegate(get_auth_credentials);
+            _self->_get_auth_credentials = Marshal.GetFunctionPointerForDelegate(_ds7);
+        }
+        
+        ~CefUrlRequestClient()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_urlrequest_client_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_urlrequest_client_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_urlrequest_client_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_urlrequest_client_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_urlrequest_client_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_urlrequest_client_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefUserData.g.cs

@@ -0,0 +1,114 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefUserData
+    {
+        private static Dictionary<IntPtr, CefUserData> _roots = new Dictionary<IntPtr, CefUserData>();
+        
+        private int _refct;
+        private cef_user_data_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        internal static CefUserData FromNativeOrNull(cef_user_data_t* ptr)
+        {
+            CefUserData value = null;
+            bool found;
+            lock (_roots)
+            {
+                found = _roots.TryGetValue((IntPtr)ptr, out value);
+            }
+            return found ? value : null;
+        }
+        
+        internal static CefUserData FromNative(cef_user_data_t* ptr)
+        {
+            var value = FromNativeOrNull(ptr);
+            if (value == null) throw ExceptionBuilder.ObjectNotFound();
+            return value;
+        }
+        
+        private cef_user_data_t.add_ref_delegate _ds0;
+        private cef_user_data_t.release_delegate _ds1;
+        private cef_user_data_t.has_one_ref_delegate _ds2;
+        
+        protected CefUserData()
+        {
+            _self = cef_user_data_t.Alloc();
+        
+            _ds0 = new cef_user_data_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_user_data_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_user_data_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+        }
+        
+        ~CefUserData()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_user_data_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_user_data_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_user_data_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_user_data_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_user_data_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_user_data_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefV8Accessor.g.cs

@@ -0,0 +1,102 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefV8Accessor
+    {
+        private static Dictionary<IntPtr, CefV8Accessor> _roots = new Dictionary<IntPtr, CefV8Accessor>();
+        
+        private int _refct;
+        private cef_v8accessor_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_v8accessor_t.add_ref_delegate _ds0;
+        private cef_v8accessor_t.release_delegate _ds1;
+        private cef_v8accessor_t.has_one_ref_delegate _ds2;
+        private cef_v8accessor_t.get_delegate _ds3;
+        private cef_v8accessor_t.set_delegate _ds4;
+        
+        protected CefV8Accessor()
+        {
+            _self = cef_v8accessor_t.Alloc();
+        
+            _ds0 = new cef_v8accessor_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_v8accessor_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_v8accessor_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_v8accessor_t.get_delegate(get);
+            _self->_get = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_v8accessor_t.set_delegate(set);
+            _self->_set = Marshal.GetFunctionPointerForDelegate(_ds4);
+        }
+        
+        ~CefV8Accessor()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_v8accessor_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_v8accessor_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_v8accessor_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_v8accessor_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_v8accessor_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_v8accessor_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefV8Context.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefV8Context : IDisposable
+    {
+        internal static CefV8Context FromNative(cef_v8context_t* ptr)
+        {
+            return new CefV8Context(ptr);
+        }
+        
+        internal static CefV8Context FromNativeOrNull(cef_v8context_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefV8Context(ptr);
+        }
+        
+        private cef_v8context_t* _self;
+        
+        private CefV8Context(cef_v8context_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefV8Context()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_v8context_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_v8context_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_v8context_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_v8context_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefV8Exception.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefV8Exception : IDisposable
+    {
+        internal static CefV8Exception FromNative(cef_v8exception_t* ptr)
+        {
+            return new CefV8Exception(ptr);
+        }
+        
+        internal static CefV8Exception FromNativeOrNull(cef_v8exception_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefV8Exception(ptr);
+        }
+        
+        private cef_v8exception_t* _self;
+        
+        private CefV8Exception(cef_v8exception_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefV8Exception()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_v8exception_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_v8exception_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_v8exception_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_v8exception_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefV8Handler.g.cs

@@ -0,0 +1,117 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefV8Handler
+    {
+        private static Dictionary<IntPtr, CefV8Handler> _roots = new Dictionary<IntPtr, CefV8Handler>();
+        
+        private int _refct;
+        private cef_v8handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        internal static CefV8Handler FromNativeOrNull(cef_v8handler_t* ptr)
+        {
+            CefV8Handler value = null;
+            bool found;
+            lock (_roots)
+            {
+                found = _roots.TryGetValue((IntPtr)ptr, out value);
+            }
+            return found ? value : null;
+        }
+        
+        internal static CefV8Handler FromNative(cef_v8handler_t* ptr)
+        {
+            var value = FromNativeOrNull(ptr);
+            if (value == null) throw ExceptionBuilder.ObjectNotFound();
+            return value;
+        }
+        
+        private cef_v8handler_t.add_ref_delegate _ds0;
+        private cef_v8handler_t.release_delegate _ds1;
+        private cef_v8handler_t.has_one_ref_delegate _ds2;
+        private cef_v8handler_t.execute_delegate _ds3;
+        
+        protected CefV8Handler()
+        {
+            _self = cef_v8handler_t.Alloc();
+        
+            _ds0 = new cef_v8handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_v8handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_v8handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_v8handler_t.execute_delegate(execute);
+            _self->_execute = Marshal.GetFunctionPointerForDelegate(_ds3);
+        }
+        
+        ~CefV8Handler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_v8handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_v8handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_v8handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_v8handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_v8handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_v8handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefV8StackFrame.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefV8StackFrame : IDisposable
+    {
+        internal static CefV8StackFrame FromNative(cef_v8stack_frame_t* ptr)
+        {
+            return new CefV8StackFrame(ptr);
+        }
+        
+        internal static CefV8StackFrame FromNativeOrNull(cef_v8stack_frame_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefV8StackFrame(ptr);
+        }
+        
+        private cef_v8stack_frame_t* _self;
+        
+        private CefV8StackFrame(cef_v8stack_frame_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefV8StackFrame()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_v8stack_frame_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_v8stack_frame_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_v8stack_frame_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_v8stack_frame_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefV8StackTrace.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefV8StackTrace : IDisposable
+    {
+        internal static CefV8StackTrace FromNative(cef_v8stack_trace_t* ptr)
+        {
+            return new CefV8StackTrace(ptr);
+        }
+        
+        internal static CefV8StackTrace FromNativeOrNull(cef_v8stack_trace_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefV8StackTrace(ptr);
+        }
+        
+        private cef_v8stack_trace_t* _self;
+        
+        private CefV8StackTrace(cef_v8stack_trace_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefV8StackTrace()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_v8stack_trace_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_v8stack_trace_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_v8stack_trace_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_v8stack_trace_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefV8Value.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefV8Value : IDisposable
+    {
+        internal static CefV8Value FromNative(cef_v8value_t* ptr)
+        {
+            return new CefV8Value(ptr);
+        }
+        
+        internal static CefV8Value FromNativeOrNull(cef_v8value_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefV8Value(ptr);
+        }
+        
+        private cef_v8value_t* _self;
+        
+        private CefV8Value(cef_v8value_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefV8Value()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_v8value_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_v8value_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_v8value_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_v8value_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefValue.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefValue : IDisposable
+    {
+        internal static CefValue FromNative(cef_value_t* ptr)
+        {
+            return new CefValue(ptr);
+        }
+        
+        internal static CefValue FromNativeOrNull(cef_value_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefValue(ptr);
+        }
+        
+        private cef_value_t* _self;
+        
+        private CefValue(cef_value_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefValue()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_value_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_value_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_value_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_value_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefWebPluginInfo.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefWebPluginInfo : IDisposable
+    {
+        internal static CefWebPluginInfo FromNative(cef_web_plugin_info_t* ptr)
+        {
+            return new CefWebPluginInfo(ptr);
+        }
+        
+        internal static CefWebPluginInfo FromNativeOrNull(cef_web_plugin_info_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefWebPluginInfo(ptr);
+        }
+        
+        private cef_web_plugin_info_t* _self;
+        
+        private CefWebPluginInfo(cef_web_plugin_info_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefWebPluginInfo()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_web_plugin_info_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_web_plugin_info_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_web_plugin_info_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_web_plugin_info_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefWebPluginInfoVisitor.g.cs

@@ -0,0 +1,99 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefWebPluginInfoVisitor
+    {
+        private static Dictionary<IntPtr, CefWebPluginInfoVisitor> _roots = new Dictionary<IntPtr, CefWebPluginInfoVisitor>();
+        
+        private int _refct;
+        private cef_web_plugin_info_visitor_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_web_plugin_info_visitor_t.add_ref_delegate _ds0;
+        private cef_web_plugin_info_visitor_t.release_delegate _ds1;
+        private cef_web_plugin_info_visitor_t.has_one_ref_delegate _ds2;
+        private cef_web_plugin_info_visitor_t.visit_delegate _ds3;
+        
+        protected CefWebPluginInfoVisitor()
+        {
+            _self = cef_web_plugin_info_visitor_t.Alloc();
+        
+            _ds0 = new cef_web_plugin_info_visitor_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_web_plugin_info_visitor_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_web_plugin_info_visitor_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_web_plugin_info_visitor_t.visit_delegate(visit);
+            _self->_visit = Marshal.GetFunctionPointerForDelegate(_ds3);
+        }
+        
+        ~CefWebPluginInfoVisitor()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_web_plugin_info_visitor_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_web_plugin_info_visitor_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_web_plugin_info_visitor_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_web_plugin_info_visitor_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_web_plugin_info_visitor_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_web_plugin_info_visitor_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefWebPluginUnstableCallback.g.cs

@@ -0,0 +1,99 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefWebPluginUnstableCallback
+    {
+        private static Dictionary<IntPtr, CefWebPluginUnstableCallback> _roots = new Dictionary<IntPtr, CefWebPluginUnstableCallback>();
+        
+        private int _refct;
+        private cef_web_plugin_unstable_callback_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_web_plugin_unstable_callback_t.add_ref_delegate _ds0;
+        private cef_web_plugin_unstable_callback_t.release_delegate _ds1;
+        private cef_web_plugin_unstable_callback_t.has_one_ref_delegate _ds2;
+        private cef_web_plugin_unstable_callback_t.is_unstable_delegate _ds3;
+        
+        protected CefWebPluginUnstableCallback()
+        {
+            _self = cef_web_plugin_unstable_callback_t.Alloc();
+        
+            _ds0 = new cef_web_plugin_unstable_callback_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_web_plugin_unstable_callback_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_web_plugin_unstable_callback_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_web_plugin_unstable_callback_t.is_unstable_delegate(is_unstable);
+            _self->_is_unstable = Marshal.GetFunctionPointerForDelegate(_ds3);
+        }
+        
+        ~CefWebPluginUnstableCallback()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_web_plugin_unstable_callback_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_web_plugin_unstable_callback_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_web_plugin_unstable_callback_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_web_plugin_unstable_callback_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_web_plugin_unstable_callback_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_web_plugin_unstable_callback_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefWriteHandler.g.cs

@@ -0,0 +1,111 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: HANDLER
+    public abstract unsafe partial class CefWriteHandler
+    {
+        private static Dictionary<IntPtr, CefWriteHandler> _roots = new Dictionary<IntPtr, CefWriteHandler>();
+        
+        private int _refct;
+        private cef_write_handler_t* _self;
+        
+        protected object SyncRoot { get { return this; } }
+        
+        private cef_write_handler_t.add_ref_delegate _ds0;
+        private cef_write_handler_t.release_delegate _ds1;
+        private cef_write_handler_t.has_one_ref_delegate _ds2;
+        private cef_write_handler_t.write_delegate _ds3;
+        private cef_write_handler_t.seek_delegate _ds4;
+        private cef_write_handler_t.tell_delegate _ds5;
+        private cef_write_handler_t.flush_delegate _ds6;
+        private cef_write_handler_t.may_block_delegate _ds7;
+        
+        protected CefWriteHandler()
+        {
+            _self = cef_write_handler_t.Alloc();
+        
+            _ds0 = new cef_write_handler_t.add_ref_delegate(add_ref);
+            _self->_base._add_ref = Marshal.GetFunctionPointerForDelegate(_ds0);
+            _ds1 = new cef_write_handler_t.release_delegate(release);
+            _self->_base._release = Marshal.GetFunctionPointerForDelegate(_ds1);
+            _ds2 = new cef_write_handler_t.has_one_ref_delegate(has_one_ref);
+            _self->_base._has_one_ref = Marshal.GetFunctionPointerForDelegate(_ds2);
+            _ds3 = new cef_write_handler_t.write_delegate(write);
+            _self->_write = Marshal.GetFunctionPointerForDelegate(_ds3);
+            _ds4 = new cef_write_handler_t.seek_delegate(seek);
+            _self->_seek = Marshal.GetFunctionPointerForDelegate(_ds4);
+            _ds5 = new cef_write_handler_t.tell_delegate(tell);
+            _self->_tell = Marshal.GetFunctionPointerForDelegate(_ds5);
+            _ds6 = new cef_write_handler_t.flush_delegate(flush);
+            _self->_flush = Marshal.GetFunctionPointerForDelegate(_ds6);
+            _ds7 = new cef_write_handler_t.may_block_delegate(may_block);
+            _self->_may_block = Marshal.GetFunctionPointerForDelegate(_ds7);
+        }
+        
+        ~CefWriteHandler()
+        {
+            Dispose(false);
+        }
+        
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_self != null)
+            {
+                cef_write_handler_t.Free(_self);
+                _self = null;
+            }
+        }
+        
+        private void add_ref(cef_write_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = ++_refct;
+                if (result == 1)
+                {
+                    lock (_roots) { _roots.Add((IntPtr)_self, this); }
+                }
+            }
+        }
+        
+        private int release(cef_write_handler_t* self)
+        {
+            lock (SyncRoot)
+            {
+                var result = --_refct;
+                if (result == 0)
+                {
+                    lock (_roots) { _roots.Remove((IntPtr)_self); }
+                    return 1;
+                }
+                return 0;
+            }
+        }
+        
+        private int has_one_ref(cef_write_handler_t* self)
+        {
+            lock (SyncRoot) { return _refct == 1 ? 1 : 0; }
+        }
+        
+        internal cef_write_handler_t* ToNative()
+        {
+            add_ref(_self);
+            return _self;
+        }
+        
+        [Conditional("DEBUG")]
+        private void CheckSelf(cef_write_handler_t* self)
+        {
+            if (_self != self) throw ExceptionBuilder.InvalidSelfReference();
+        }
+        
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefXmlReader.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefXmlReader : IDisposable
+    {
+        internal static CefXmlReader FromNative(cef_xml_reader_t* ptr)
+        {
+            return new CefXmlReader(ptr);
+        }
+        
+        internal static CefXmlReader FromNativeOrNull(cef_xml_reader_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefXmlReader(ptr);
+        }
+        
+        private cef_xml_reader_t* _self;
+        
+        private CefXmlReader(cef_xml_reader_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefXmlReader()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_xml_reader_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_xml_reader_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_xml_reader_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_xml_reader_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}

插件库/CommonLib/Cef3.24/Classes.g/CefZipReader.g.cs

@@ -0,0 +1,74 @@
+//
+// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
+//
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    
+    // Role: PROXY
+    public sealed unsafe partial class CefZipReader : IDisposable
+    {
+        internal static CefZipReader FromNative(cef_zip_reader_t* ptr)
+        {
+            return new CefZipReader(ptr);
+        }
+        
+        internal static CefZipReader FromNativeOrNull(cef_zip_reader_t* ptr)
+        {
+            if (ptr == null) return null;
+            return new CefZipReader(ptr);
+        }
+        
+        private cef_zip_reader_t* _self;
+        
+        private CefZipReader(cef_zip_reader_t* ptr)
+        {
+            if (ptr == null) throw new ArgumentNullException("ptr");
+            _self = ptr;
+        }
+        
+        ~CefZipReader()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+        }
+        
+        public void Dispose()
+        {
+            if (_self != null)
+            {
+                Release();
+                _self = null;
+            }
+            GC.SuppressFinalize(this);
+        }
+        
+        internal void AddRef()
+        {
+            cef_zip_reader_t.add_ref(_self);
+        }
+        
+        internal bool Release()
+        {
+            return cef_zip_reader_t.release(_self) != 0;
+        }
+        
+        internal bool HasOneRef
+        {
+            get { return cef_zip_reader_t.has_one_ref(_self) != 0; }
+        }
+        
+        internal cef_zip_reader_t* ToNative()
+        {
+            AddRef();
+            return _self;
+        }
+    }
+}