IUrlRequest - Minor formatting and xml doc improvements

- Formatting
- Xml doc improvements
- Rewrite test case to run continuation async

Issue #2881

Author: amaitland

CefSharp.Core/Internals/CefFrameWrapper.cpp

@@ -413,6 +413,16 @@ IUrlRequest^ CefFrameWrapper::CreateUrlRequest(IRequest^ request, IUrlRequestCli
 {
     ThrowIfDisposed();
 
+    if (request == nullptr)
+    {
+        throw gcnew ArgumentNullException("request");
+    }
+
+    if (client == nullptr)
+    {
+        throw gcnew ArgumentNullException("client");
+    }
+
     auto urlRequest = _frame->CreateURLRequest(
         (CefRequestWrapper^)request,
         new CefUrlRequestClientAdapter(client));

CefSharp.Core/Internals/CefUrlRequestClientAdapter.cpp

@@ -27,6 +27,7 @@ void CefUrlRequestClientAdapter::OnDownloadProgress(CefRefPtr<CefURLRequest> req
 void CefUrlRequestClientAdapter::OnDownloadData(CefRefPtr<CefURLRequest> request, const void* data, size_t data_length)
 {
     UnmanagedMemoryStream readStream((Byte*)data, (Int64)data_length, (Int64)data_length, FileAccess::Read);
+
     _client->OnDownloadData(
         gcnew CefUrlRequestWrapper(request),
         %readStream

CefSharp.Core/Internals/CefUrlRequestClientAdapter.h

@@ -11,7 +11,6 @@ namespace CefSharp
 {
     namespace Internals
     {
-
         /// Interface that should be implemented by the CefUrlRequest client.
         /// The methods of this class will be called on the same thread that created
         /// the request unless otherwise documented. 

CefSharp.Core/Internals/CefUrlRequestWrapper.h

@@ -21,7 +21,7 @@ namespace CefSharp
         // be accessed on the same thread that created it. 
         ///
         /*--cef(source=library)--*/
-        ref class CefUrlRequestWrapper : public IUrlRequest, public CefWrapper
+        public ref class CefUrlRequestWrapper : public IUrlRequest, public CefWrapper
         {
         private:
             MCefRefPtr<CefURLRequest> _urlRequest;
@@ -51,7 +51,7 @@ namespace CefSharp
             {
                 bool get();
             }
-            
+
             ///
             // Returns the response, or NULL if no response information is available.
             // Response information will only be available after the upload has completed.

CefSharp.Example/UrlRequestClient.cs

@@ -7,40 +7,39 @@
 
 namespace CefSharp.Example
 {
-
     public class UrlRequestClient : IUrlRequestClient
     {
-        private Action<IUrlRequest, byte[]> CompleteAction;
-        private MemoryStream ResponseBody = new MemoryStream();
+        private readonly Action<IUrlRequest, byte[]> completeAction;
+        private readonly MemoryStream responseBody = new MemoryStream();
 
         public UrlRequestClient(Action<IUrlRequest, byte[]> completeAction)
         {
-            CompleteAction = completeAction;
+            this.completeAction = completeAction;
         }
-        public bool GetAuthCredentials(bool isProxy, string host, int port, string realm, string scheme, IAuthCallback callback)
+
+        bool IUrlRequestClient.GetAuthCredentials(bool isProxy, string host, int port, string realm, string scheme, IAuthCallback callback)
         {
             return true;
         }
 
-        public void OnDownloadData(IUrlRequest request, Stream data)
+        void IUrlRequestClient.OnDownloadData(IUrlRequest request, Stream data)
         {
-            data.CopyTo(ResponseBody);
+            data.CopyTo(responseBody);
         }
 
-        public void OnDownloadProgress(IUrlRequest request, long current, long total)
+        void IUrlRequestClient.OnDownloadProgress(IUrlRequest request, long current, long total)
         {
-            return;
+
         }
 
-        public void OnRequestComplete(IUrlRequest request)
+        void IUrlRequestClient.OnRequestComplete(IUrlRequest request)
         {
-
-            CompleteAction(request, ResponseBody.ToArray());
+            this?.completeAction(request, responseBody.ToArray());
         }
 
-        public void OnUploadProgress(IUrlRequest request, long current, long total)
+        void IUrlRequestClient.OnUploadProgress(IUrlRequest request, long current, long total)
         {
-            return;
+
         }
     }
 }

CefSharp.Test/OffScreen/OffScreenBrowserBasicFacts.cs

@@ -2,14 +2,12 @@
 //
 // Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
 
-using System;
-using System.IO;
-using System.Threading;
-using CefSharp.OffScreen;
+using System.Text;
 using System.Threading.Tasks;
+using CefSharp.Example;
+using CefSharp.OffScreen;
 using Xunit;
 using Xunit.Abstractions;
-using CefSharp.Example;
 
 namespace CefSharp.Test.OffScreen
 {
@@ -142,18 +140,13 @@ public async Task CanMakeUrlRequest()
                 var mainFrame = browser.GetMainFrame();
                 Assert.True(mainFrame.IsValid);
 
-
-                IUrlRequest urlRequest = null;
-
-                var t = new TaskCompletionSource<string>();
+                var taskCompletionSource = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
                 var wasCached = false;
-                var requestClient = new UrlRequestClient(
-                    (IUrlRequest request, byte[] responseBody) =>
-                    {
-                        wasCached = request.ResponseWasCached;
-                        t.TrySetResult(System.Text.Encoding.UTF8.GetString(responseBody));
-                    }
-                );
+                var requestClient = new UrlRequestClient((IUrlRequest req, byte[] responseBody) =>
+                {
+                    wasCached = req.ResponseWasCached;
+                    taskCompletionSource.TrySetResult(Encoding.UTF8.GetString(responseBody));
+                });
 
                 //Make the request on the CEF UI Thread
                 await Cef.UIThreadTaskFactory.StartNew(delegate
@@ -162,10 +155,10 @@ await Cef.UIThreadTaskFactory.StartNew(delegate
 
                     request.Method = "GET";
                     request.Url = "https://code.jquery.com/jquery-3.4.1.min.js";
-                    urlRequest = mainFrame.CreateUrlRequest(request, requestClient);
+                    var urlRequest = mainFrame.CreateUrlRequest(request, requestClient);
                 });
 
-                var stringResult = await t.Task;
+                var stringResult = await taskCompletionSource.Task;
 
                 Assert.True(!string.IsNullOrEmpty(stringResult));
                 Assert.True(wasCached);

CefSharp/IUrlRequest.cs

@@ -19,7 +19,7 @@ public interface IUrlRequest : IDisposable
         /// True if the response was served from the cache.
         /// </summary>
         bool ResponseWasCached { get; }
-        
+
         /// <summary>
         /// The response, or null if no response information is available
         /// </summary>

CefSharp/IUrlRequestClient.cs

@@ -13,51 +13,51 @@ namespace CefSharp
     public interface IUrlRequestClient
     {
         /// <summary>
-        /// Called on the IO thread when the browser needs credentials from the user.
+        /// Called on the CEF IO thread when the browser needs credentials from the user.
         /// This method will only be called for requests initiated from the browser process. 
         /// </summary>
         /// <param name="isProxy">indicates whether the host is a proxy server.</param>
         /// <param name="host">the hostname.</param>
         /// <param name="port">the port number.</param>
-        /// <param name="realm"></param>
-        /// <param name="scheme"></param>
+        /// <param name="realm">realm</param>
+        /// <param name="scheme">scheme</param>
         /// <param name="callback">is a callback for authentication information</param>
         /// <returns>
-        /// Return true to continue the request and call IAuthCallback.Continue() when the authentication information is available.
-        /// If the request has an associated browser/frame then returning false will result in a call to GetAuthCredentials
-        /// on the IRequestHandler associated with that browser, if any.
+        /// Return true to continue the request and call <see cref="IAuthCallback.Continue(string, string)"/> when the authentication information is available.
+        /// If the request has an associated browser/frame then returning false will result in a call to <see cref="IRequestHandler.GetAuthCredentials"/> 
+        /// on the <see cref="IRequestHandler"/> associated with that browser, if any.
         /// Otherwise, returning false will cancel the request immediately.
         /// </returns>
-
         bool GetAuthCredentials(bool isProxy, string host, int port, string realm, string scheme, IAuthCallback callback);
+
         /// <summary>
-        /// Called when some part of the response is read. This method will not be called if the UR_FLAG_NO_DOWNLOAD_DATA flag is set on the request. 
+        /// Called when some part of the response is read. This method will not be called if the <see cref="UrlRequestFlags.NoDownloadData"/> flag is set on the request. 
         /// </summary>
-        /// <param name="request"></param>
-        /// <param name="data">Contains the current bytes received since the last call.</param>
+        /// <param name="request">request</param>
+        /// <param name="data">A stream containing the bytes received since the last call. Cannot be used outside the scope of this method. </param>
         void OnDownloadData(IUrlRequest request, Stream data);
 
         /// <summary>
         /// Notifies the client of download progress.
         /// </summary>
-        /// <param name="request"></param>
+        /// <param name="request">request</param>
         /// <param name="current">denotes the number of bytes received up to the call </param>
         /// <param name="total">is the expected total size of the response (or -1 if not determined).</param>
         void OnDownloadProgress(IUrlRequest request, long current, long total);
 
         /// <summary>
-        /// Notifies the client that the request has completed. Use the
-        /// IURLRequest.GetRequestStatus method to determine if the request was
-        /// successful or not.
+        /// Notifies the client that the request has completed.
+        /// Use the <see cref="IUrlRequest.RequestStatus"/> property to determine if the
+        /// request was successful or not.
         /// </summary>
-        /// <param name="request"></param>
+        /// <param name="request">request</param>
         void OnRequestComplete(IUrlRequest request);
 
         /// <summary>
         /// Notifies the client of upload progress.
         /// This method will only be called if the UR_FLAG_REPORT_UPLOAD_PROGRESS flag is set on the request.
         /// </summary>
-        /// <param name="request"></param>
+        /// <param name="request">request</param>
         /// <param name="current">denotes the number of bytes sent so far.</param>
         /// <param name="total">is the total size of uploading data (or -1 if chunked upload is enabled).</param>
         void OnUploadProgress(IUrlRequest request, long current, long total);