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); }); } } }