private async void HandleLoadToFile(object sender, EventArgs e)
{
CefUrlRequestStatus status = CefUrlRequestStatus.Unknown;
string url = "https://speed.hetzner.de/100MB.bin";
using (var dlg = new SaveFileDialog())
{
dlg.FileName = Path.GetFileName(url);
dlg.Filter = "All Files (*.*)|*.*";
if (dlg.ShowDialog() == DialogResult.OK)
{
var r = new CustomWebRequest();
r.IgnoreSize = MessageBox.Show("Download 100MB file?", "Download file...", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes;
try
{
await r.DownloadFileAsync(new CefRequest { Url = url }, null, dlg.FileName, CancellationToken.None);
}
catch (Exception ex)
{
Program.ShowUnhandledException(ex, "MainForm");
}
finally
{
status = r.RequestStatus;
}
}
}
MessageBox.Show($"Complete ({status})!");
}
/// <summary>
/// Notifies that the request has completed.
/// </summary>
/// <param name="request">The associated <see cref="CefUrlRequest"/>.</param>
/// <remarks>
/// Use the <see cref="CefUrlRequest.RequestStatus"/> to determine
/// if the request was successful or not.
/// </remarks>
protected internal override void OnRequestComplete(CefUrlRequest request)
{
if (_stream != null)
{
try
{
_stream.Flush();
if (_stream.CanSeek)
{
_stream.Seek(0, SeekOrigin.Begin);
}
}
catch (IOException ioe)
{
SetException(ioe);
}
}
_request = request.Request;
_response = request.Response;
_requestStatus = request.RequestStatus;
this.RequestError = request.RequestError;
this.ResponseWasCached = request.ResponseWasCached();
IsCompleted = true;
RequestOperation op = Volatile.Read(ref _activeOperation);
if (op is null || op.continuation is null)
{
return;
}
ThreadPool.QueueUserWorkItem(cont => ((Action)cont)(), op.continuation);
}
/// <summary>
/// Sends the request to the server as an asynchronous operation.<para/>
/// For requests originating from the browser process:
/// <list type="bullet">
/// <item>
/// <description>
/// It may be intercepted by the client via CefResourceRequestHandler or
/// CefSchemeHandlerFactory;
/// </description>
/// </item>
/// <item>
/// <description>
/// POST data may only contain only a single element of type
/// <see cref="CefPostDataElementType.File"/> or <see cref="CefPostDataElementType.Bytes"/>.
/// </description>
/// </item>
/// </list>
/// For requests originating from the render process:
/// <list type="bullet">
/// <item>
/// <description>
/// It cannot be intercepted by the client so only http(s) and blob schemes
/// are supported.
/// </description>
/// </item>
/// <item>
/// <description>
/// POST data may only contain a single element of type <see cref="CefPostDataElementType.Bytes"/>.
/// </description>
/// </item>
/// </list>
/// </summary>
/// <param name="request">
/// The <see cref="CefRequest"/> object to send. It will be marked as read-only after calling
/// this function.
/// </param>
/// <param name="context">
/// A request context or null, if <paramref name="context"/> is empty the global
/// request context will be used. For requests originating from the render process
/// this parameter must be null.
/// </param>
/// <param name="cancellationToken">The cancellation token to cancel operation.</param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <remarks>
/// This operation will not block. The returned <see cref="Task"/> object will complete once
/// the entire response including content is read.
/// </remarks>
public async Task SendAsync(CefRequest request, CefRequestContext context, CancellationToken cancellationToken)
{
if (CefNetApplication.ProcessType != ProcessType.Main && context != null)
{
throw new ArgumentOutOfRangeException(nameof(context));
}
if (Interlocked.CompareExchange(ref _activeOperation, new RequestOperation(), null) != null)
{
throw new InvalidOperationException();
}
_request = request;
_response = null;
_exception = null;
if (_stream != null)
{
_stream.Dispose();
_stream = null;
}
_requestStatus = CefUrlRequestStatus.Unknown;
this.RequestError = CefErrorCode.None;
this.ResponseWasCached = false;
this.IsCompleted = false;
try
{
_activeOperation.request = await CreateUrlRequest(request, context, cancellationToken).ConfigureAwait(false);
using (cancellationToken.Register(Abort))
{
await this;
}
}
finally
{
Interlocked.Exchange(ref _activeOperation, null);
}
Exception exception = Volatile.Read(ref _exception);
if (exception is null)
{
return;
}
ExceptionDispatchInfo.Capture(exception).Throw();
}
public unsafe extern void OnResourceLoadComplete(cef_browser_t *browser, cef_frame_t *frame, cef_request_t *request, cef_response_t *response, CefUrlRequestStatus status, long received_content_length);
/// <summary>
/// Called on the IO thread when a resource load has completed. |request| and
/// |response| represent the request and response respectively and cannot be
/// modified in this callback. |status| indicates the load completion status.
/// |received_content_length| is the number of response bytes actually read.
/// </summary>
protected virtual void OnResourceLoadComplete(CefBrowser browser, CefFrame frame, CefRequest request, CefResponse response, CefUrlRequestStatus status, long receivedContentLength)
{
}
private void on_resource_load_complete(cef_request_handler_t *self, cef_browser_t *browser, cef_frame_t *frame, cef_request_t *request, cef_response_t *response, CefUrlRequestStatus status, long received_content_length)
{
CheckSelf(self);
var mBrowser = CefBrowser.FromNative(browser);
var mFrame = CefFrame.FromNative(frame);
var mRequest = CefRequest.FromNative(request);
var mResponse = CefResponse.FromNative(response);
OnResourceLoadComplete(mBrowser, mFrame, mRequest, mResponse, status, received_content_length);
}
public unsafe void OnResourceLoadComplete(cef_browser_t *browser, cef_frame_t *frame, cef_request_t *request, cef_response_t *response, CefUrlRequestStatus status, long received_content_length)
{
fixed(cef_resource_request_handler_t *self = &this)
{
((delegate * unmanaged[Stdcall] < cef_resource_request_handler_t *, cef_browser_t *, cef_frame_t *, cef_request_t *, cef_response_t *, CefUrlRequestStatus, long, void >)on_resource_load_complete)(self, browser, frame, request, response, status, received_content_length);
}
}
protected override void OnResourceLoadComplete(CefBrowser browser, CefFrame frame, CefRequest request, CefResponse response, CefUrlRequestStatus status, long receivedContentLength)
{
logic.OnResourceLoadComplete(request);
}
protected internal unsafe override void OnResourceLoadComplete(CefBrowser browser, CefFrame frame, CefRequest request, CefResponse response, CefUrlRequestStatus status, long receivedContentLength)
{
_implementation.OnResourceLoadComplete(browser, frame, request, response, status, receivedContentLength);
}
//static readonly string[] urls = new[]
//{
// "https://localhost",
//};
//protected override CefReturnValue OnBeforeResourceLoad(CefBrowser browser, CefFrame frame, CefRequest request, CefRequestCallback callback)
//{
// //using var header = new CefStringMultimap();
// //request.GetHeaderMap(header);
// //var header_new = new CefStringMultimap();
// //foreach (var item in header.AllKeys)
// //{
// // string value;
// // if ("Accept-Language".Equals(item, StringComparison.OrdinalIgnoreCase))
// // {
// // value = R.GetAcceptLanguage();
// // }
// // else
// // {
// // value = header[item];
// // }
// // header_new.Add(item, value);
// //}
// //request.SetHeaderMap(header_new);
// //if (urls.Any(x => request.Url.StartsWith(x, StringComparison.OrdinalIgnoreCase)))
// //{
// // request.SetHeaderByName("Accept-Language2", R.AcceptLanguage, true);
// //}
// var returnValue = base.OnBeforeResourceLoad(browser, frame, request, callback);
// return returnValue;
//}
protected override void OnResourceLoadComplete(CefBrowser browser, CefFrame frame, CefRequest request, CefResponse response, CefUrlRequestStatus status, long receivedContentLength)
{
base.OnResourceLoadComplete(browser, frame, request, response, status, receivedContentLength);
if (responseDictionary.TryGetValue(request.Identifier, out var filter))
{
if (webView.OnStreamResponseFilterResourceLoadComplete != null)
{
Task.Run(() =>
{
webView.OnStreamResponseFilterResourceLoadComplete(request.Url, filter.Data);
});
}
}
}
