init lserp cs 5.0

2026-07-10 15:25:05 +08:00
commit 90f3fda86a
3799 changed files with 976868 additions and 0 deletions
@@ -0,0 +1,138 @@
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+    using System.IO;
+
+    /// <summary>
+    /// Class used to implement a custom request handler interface. The methods of
+    /// this class will always be called on the IO thread.
+    /// </summary>
+    public abstract unsafe partial class CefResourceHandler
+    {
+        private int process_request(cef_resource_handler_t* self, cef_request_t* request, cef_callback_t* callback)
+        {
+            CheckSelf(self);
+
+            var m_request = CefRequest.FromNative(request);
+            var m_callback = CefCallback.FromNative(callback);
+
+            var result = ProcessRequest(m_request, m_callback);
+            return result ? 1 : 0;
+        }
+
+        /// <summary>
+        /// Begin processing the request. To handle the request return true and call
+        /// CefCallback::Continue() once the response header information is available
+        /// (CefCallback::Continue() can also be called from inside this method if
+        /// header information is available immediately). To cancel the request return
+        /// false.
+        /// </summary>
+        protected abstract bool ProcessRequest(CefRequest request, CefCallback callback);
+
+
+        private void get_response_headers(cef_resource_handler_t* self, cef_response_t* response, long* response_length, cef_string_t* redirectUrl)
+        {
+            CheckSelf(self);
+
+            var m_response = CefResponse.FromNative(response);
+            long m_responseLength;
+            string m_redirectUrl;
+
+            GetResponseHeaders(m_response, out m_responseLength, out m_redirectUrl);
+
+            *response_length = m_responseLength;
+
+            if (!string.IsNullOrEmpty(m_redirectUrl))
+            {
+                cef_string_t.Copy(m_redirectUrl, redirectUrl);
+            }
+        }
+
+        /// <summary>
+        /// Retrieve response header information. If the response length is not known
+        /// set |response_length| to -1 and ReadResponse() will be called until it
+        /// returns false. If the response length is known set |response_length|
+        /// to a positive value and ReadResponse() will be called until it returns
+        /// false or the specified number of bytes have been read. Use the |response|
+        /// object to set the mime type, http status code and other optional header
+        /// values. To redirect the request to a new URL set |redirectUrl| to the new
+        /// URL.
+        /// </summary>
+        protected abstract void GetResponseHeaders(CefResponse response, out long responseLength, out string redirectUrl);
+
+
+        private int read_response(cef_resource_handler_t* self, void* data_out, int bytes_to_read, int* bytes_read, cef_callback_t* callback)
+        {
+            CheckSelf(self);
+
+            var m_callback = CefCallback.FromNative(callback);
+
+            using (var m_stream = new UnmanagedMemoryStream((byte*)data_out, bytes_to_read, bytes_to_read, FileAccess.Write))
+            {
+                int m_bytesRead;
+                var result = ReadResponse(m_stream, bytes_to_read, out m_bytesRead, m_callback);
+                *bytes_read = m_bytesRead;
+                return result ? 1 : 0;
+            }
+        }
+
+        /// <summary>
+        /// Read response data. If data is available immediately copy up to
+        /// |bytes_to_read| bytes into |data_out|, set |bytes_read| to the number of
+        /// bytes copied, and return true. To read the data at a later time set
+        /// |bytes_read| to 0, return true and call CefCallback::Continue() when the
+        /// data is available. To indicate response completion return false.
+        /// </summary>
+        protected abstract bool ReadResponse(Stream response, int bytesToRead, out int bytesRead, CefCallback callback);
+
+
+        private int can_get_cookie(cef_resource_handler_t* self, cef_cookie_t* cookie)
+        {
+            CheckSelf(self);
+
+            var m_cookie = CefCookie.FromNative(cookie);
+
+            return CanGetCookie(m_cookie) ? 1 : 0;
+        }
+
+        /// <summary>
+        /// Return true if the specified cookie can be sent with the request or false
+        /// otherwise. If false is returned for any cookie then no cookies will be sent
+        /// with the request.
+        /// </summary>
+        protected abstract bool CanGetCookie(CefCookie cookie);
+
+
+        private int can_set_cookie(cef_resource_handler_t* self, cef_cookie_t* cookie)
+        {
+            CheckSelf(self);
+
+            var m_cookie = CefCookie.FromNative(cookie);
+
+            return CanSetCookie(m_cookie) ? 1 : 0;
+        }
+
+        /// <summary>
+        /// Return true if the specified cookie returned with the response can be set
+        /// or false otherwise.
+        /// </summary>
+        protected abstract bool CanSetCookie(CefCookie cookie);
+
+
+        private void cancel(cef_resource_handler_t* self)
+        {
+            CheckSelf(self);
+
+            Cancel();
+        }
+
+        /// <summary>
+        /// Request processing has been canceled.
+        /// </summary>
+        protected abstract void Cancel();
+    }
+}