OpenIdProviderWebForms now builds.

11 files changed, 125 insertions, 32 deletions

diff --git a/samples/OpenIdProviderWebForms/Code/Util.cs b/samples/OpenIdProviderWebForms/Code/Util.cs
index deff447..224ec24 100644
--- a/samples/OpenIdProviderWebForms/Code/Util.cs
+++ b/samples/OpenIdProviderWebForms/Code/Util.cs
@@ -6,11 +6,13 @@
 
 namespace OpenIdProviderWebForms.Code {
 	using System;
+	using System.Threading;
+	using System.Threading.Tasks;
 	using System.Web;
 	using DotNetOpenAuth.OpenId;
 	using DotNetOpenAuth.OpenId.Provider;
 
-	public class Util {
+	public static class Util {
 		public static string ExtractUserName(Uri url) {
 			return url.Segments[url.Segments.Length - 1];
 		}
@@ -71,5 +73,33 @@ namespace OpenIdProviderWebForms.Code {
 				HttpContext.Current.Response.Redirect("~/decide.aspx", true);
 			}
 		}
+
+		internal static Task ToApm(this Task task, AsyncCallback callback, object state) {
+			if (task == null) {
+				throw new ArgumentNullException("task");
+			}
+
+			var tcs = new TaskCompletionSource<object>(state);
+			task.ContinueWith(
+				t => {
+					if (t.IsFaulted) {
+						tcs.TrySetException(t.Exception.InnerExceptions);
+					} else if (t.IsCanceled) {
+						tcs.TrySetCanceled();
+					} else {
+						tcs.TrySetResult(null);
+					}
+
+					if (callback != null) {
+						callback(tcs.Task);
+					}
+				},
+				CancellationToken.None,
+				TaskContinuationOptions.None,
+				TaskScheduler.Default);
+
+			return tcs.Task;
+		}
+
 	}
 }
\ No newline at end of file
diff --git a/samples/OpenIdProviderWebForms/Default.aspx b/samples/OpenIdProviderWebForms/Default.aspx
index 4f9e4bc..dfa056c 100644
--- a/samples/OpenIdProviderWebForms/Default.aspx
+++ b/samples/OpenIdProviderWebForms/Default.aspx
@@ -1,5 +1,5 @@
 <%@ Page Language="C#" AutoEventWireup="true" MasterPageFile="~/Site.Master" CodeBehind="Default.aspx.cs"
-	Inherits="OpenIdProviderWebForms._default" %>
+	Inherits="OpenIdProviderWebForms._default" Async="true" %>
 
 <%@ Import Namespace="OpenIdProviderWebForms.Code" %>
 <%@ Register Assembly="DotNetOpenAuth.OpenId.UI" Namespace="DotNetOpenAuth.OpenId" TagPrefix="openid" %>
diff --git a/samples/OpenIdProviderWebForms/Default.aspx.cs b/samples/OpenIdProviderWebForms/Default.aspx.cs
index 4843639..05e108d 100644
--- a/samples/OpenIdProviderWebForms/Default.aspx.cs
+++ b/samples/OpenIdProviderWebForms/Default.aspx.cs
@@ -1,5 +1,6 @@
 namespace OpenIdProviderWebForms {
 	using System;
+	using System.Threading.Tasks;
 	using System.Web.Security;
 	using System.Web.UI.WebControls;
 	using DotNetOpenAuth.Messaging;
@@ -11,10 +12,10 @@
 	/// Page for handling logins to this server. 
 	/// </summary>
 	public partial class _default : System.Web.UI.Page {
-		protected void Page_Load(object sender, EventArgs e) {
+		protected async void Page_Load(object sender, EventArgs e) {
 			if (Request.QueryString["rp"] != null) {
 				if (Page.User.Identity.IsAuthenticated) {
-					this.SendAssertion(Request.QueryString["rp"]);
+					await this.SendAssertionAsync(Request.QueryString["rp"]);
 				} else {
 					FormsAuthentication.RedirectToLoginPage();
 				}
@@ -26,18 +27,19 @@
 			}
 		}
 
-		protected void sendAssertionButton_Click(object sender, EventArgs e) {
+		protected async void sendAssertionButton_Click(object sender, EventArgs e) {
 			TextBox relyingPartySite = (TextBox)this.loginView.FindControl("relyingPartySite");
-			this.SendAssertion(relyingPartySite.Text);
+			await this.SendAssertionAsync(relyingPartySite.Text);
 		}
 
-		private void SendAssertion(string relyingPartyRealm) {
+		private async Task SendAssertionAsync(string relyingPartyRealm) {
 			Uri providerEndpoint = new Uri(Request.Url, Page.ResolveUrl("~/server.aspx"));
 			OpenIdProvider op = new OpenIdProvider();
 			try {
 				// Send user input through identifier parser so we accept more free-form input.
 				string rpSite = Identifier.Parse(relyingPartyRealm);
-				op.PrepareUnsolicitedAssertion(providerEndpoint, rpSite, Util.BuildIdentityUrl(), Util.BuildIdentityUrl()).Send();
+				var response = await op.PrepareUnsolicitedAssertionAsync(providerEndpoint, rpSite, Util.BuildIdentityUrl(), Util.BuildIdentityUrl());
+				await response.SendAsync();
 			} catch (ProtocolException ex) {
 				Label errorLabel = (Label)this.loginView.FindControl("errorLabel");
 				errorLabel.Visible = true;
diff --git a/samples/OpenIdProviderWebForms/OpenIdProviderWebForms.csproj b/samples/OpenIdProviderWebForms/OpenIdProviderWebForms.csproj
index 23d73d9..d756726 100644
--- a/samples/OpenIdProviderWebForms/OpenIdProviderWebForms.csproj
+++ b/samples/OpenIdProviderWebForms/OpenIdProviderWebForms.csproj
@@ -69,6 +69,8 @@
     <Reference Include="System.Data" />
     <Reference Include="System.Data.DataSetExtensions" />
     <Reference Include="System.Drawing" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Net.Http.WebRequest" />
     <Reference Include="System.Web" />
     <Reference Include="System.Web.DynamicData" />
     <Reference Include="System.Web.Entity" />
diff --git a/samples/OpenIdProviderWebForms/Provider.ashx.cs b/samples/OpenIdProviderWebForms/Provider.ashx.cs
index f8fa4a3..8022aae 100644
--- a/samples/OpenIdProviderWebForms/Provider.ashx.cs
+++ b/samples/OpenIdProviderWebForms/Provider.ashx.cs
@@ -1,8 +1,14 @@
 namespace OpenIdProviderWebForms {
+	using System;
+	using System.Threading;
+	using System.Threading.Tasks;
 	using System.Web;
 	using System.Web.SessionState;
+	using DotNetOpenAuth.Messaging;
 	using DotNetOpenAuth.OpenId.Provider;
 
+	using OpenIdProviderWebForms.Code;
+
 	/// <summary>
 	/// A fast OpenID message handler that responds to OpenID messages
 	/// directed at the Provider.
@@ -12,13 +18,13 @@
 	/// control to reduce the amount of source code in the web site.  A typical Provider
 	/// site will have EITHER this .ashx handler OR the .aspx page -- NOT both.
 	/// </remarks>
-	public class Provider : IHttpHandler, IRequiresSessionState {
+	public class Provider : IHttpAsyncHandler, IRequiresSessionState {
 		public bool IsReusable {
 			get { return true; }
 		}
 
-		public void ProcessRequest(HttpContext context) {
-			IRequest request = ProviderEndpoint.Provider.GetRequest();
+		private async Task ProcessRequestAsync(HttpContext context) {
+			IRequest request = await ProviderEndpoint.Provider.GetRequestAsync(new HttpRequestWrapper(context.Request), context.Response.ClientDisconnectedToken);
 			if (request != null) {
 				// Some OpenID requests are automatable and can be responded to immediately.
 				// But authentication requests cannot be responded to until something on
@@ -51,12 +57,26 @@
 					// We DON'T use ProviderEndpoint.SendResponse because
 					// that only sends responses to requests in PendingAuthenticationRequest,
 					// but we don't set that for associate and other non-checkid requests.
-					ProviderEndpoint.Provider.Respond(request);
+					var response = await ProviderEndpoint.Provider.PrepareResponseAsync(request, context.Response.ClientDisconnectedToken);
 
 					// Make sure that any PendingAuthenticationRequest that MAY be set is cleared.
 					ProviderEndpoint.PendingRequest = null;
+
+					await response.SendAsync(new HttpResponseWrapper(context.Response));
 				}
 			}
 		}
+
+		public IAsyncResult BeginProcessRequest(HttpContext context, System.AsyncCallback cb, object extraData) {
+			return this.ProcessRequestAsync(context).ToApm(cb, extraData);
+		}
+
+		public void EndProcessRequest(IAsyncResult result) {
+			((Task)result).Wait(); // rethrows exceptions
+		}
+
+		public void ProcessRequest(HttpContext context) {
+			this.ProcessRequestAsync(context).GetAwaiter().GetResult();
+		}
 	}
 }
diff --git a/samples/OpenIdProviderWebForms/access_token.ashx.cs b/samples/OpenIdProviderWebForms/access_token.ashx.cs
index 1e3d27c..afee82c 100644
--- a/samples/OpenIdProviderWebForms/access_token.ashx.cs
+++ b/samples/OpenIdProviderWebForms/access_token.ashx.cs
@@ -2,22 +2,42 @@
 	using System;
 	using System.Collections.Generic;
 	using System.Linq;
+	using System.Threading.Tasks;
 	using System.Web;
 	using System.Web.Services;
 	using DotNetOpenAuth.OAuth;
+	using DotNetOpenAuth.Messaging;
 	using OpenIdProviderWebForms.Code;
+	using System.Threading;
 
 	[WebService(Namespace = "http://tempuri.org/")]
 	[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
-	public class access_token : IHttpHandler {
+	public class access_token : IHttpAsyncHandler {
 		public bool IsReusable {
 			get { return true; }
 		}
 
-		public void ProcessRequest(HttpContext context) {
-			var request = OAuthHybrid.ServiceProvider.ReadAccessTokenRequest();
+		public async Task ProcessRequestAsync(HttpContext context) {
+			var request = await OAuthHybrid.ServiceProvider.ReadAccessTokenRequestAsync(
+				new HttpRequestWrapper(context.Request),
+				context.Response.ClientDisconnectedToken);
 			var response = OAuthHybrid.ServiceProvider.PrepareAccessTokenMessage(request);
-			OAuthHybrid.ServiceProvider.Channel.Respond(response);
+			var httpResponseMessage = await OAuthHybrid.ServiceProvider.Channel.PrepareResponseAsync(
+				response,
+				context.Response.ClientDisconnectedToken);
+			await httpResponseMessage.SendAsync();
+		}
+
+		public void ProcessRequest(HttpContext context) {
+			this.ProcessRequestAsync(context).GetAwaiter().GetResult();
+		}
+
+		public IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData) {
+			return this.ProcessRequestAsync(context).ToApm(cb, extraData);
+		}
+
+		public void EndProcessRequest(IAsyncResult result) {
+			((Task)result).Wait(); // rethrows exceptions
 		}
 	}
 }
diff --git a/samples/OpenIdProviderWebForms/decide.aspx b/samples/OpenIdProviderWebForms/decide.aspx
index d63364e..b6219ff 100644
--- a/samples/OpenIdProviderWebForms/decide.aspx
+++ b/samples/OpenIdProviderWebForms/decide.aspx
@@ -1,5 +1,5 @@
 <%@ Page Language="C#" AutoEventWireup="true" Inherits="OpenIdProviderWebForms.decide"
-	CodeBehind="decide.aspx.cs" MasterPageFile="~/Site.Master" %>
+	CodeBehind="decide.aspx.cs" MasterPageFile="~/Site.Master" Async="true" %>
 
 <%@ Register Src="ProfileFields.ascx" TagName="ProfileFields" TagPrefix="uc1" %>
 <asp:Content runat="server" ContentPlaceHolderID="Main">
diff --git a/samples/OpenIdProviderWebForms/decide.aspx.cs b/samples/OpenIdProviderWebForms/decide.aspx.cs
index 8c8f927..88f222f 100644
--- a/samples/OpenIdProviderWebForms/decide.aspx.cs
+++ b/samples/OpenIdProviderWebForms/decide.aspx.cs
@@ -3,6 +3,7 @@ namespace OpenIdProviderWebForms {
 	using System.Diagnostics;
 	using System.Web.Security;
 	using System.Web.UI;
+	using DotNetOpenAuth.Messaging;
 	using DotNetOpenAuth.OpenId.Extensions.ProviderAuthenticationPolicy;
 	using DotNetOpenAuth.OpenId.Extensions.SimpleRegistration;
 	using DotNetOpenAuth.OpenId.Provider;
@@ -12,13 +13,13 @@ namespace OpenIdProviderWebForms {
 	/// Page for giving the user the option to continue or cancel out of authentication with a consumer.
 	/// </summary>
 	public partial class decide : Page {
-		protected void Page_Load(object src, EventArgs e) {
+		protected async void Page_Load(object src, EventArgs e) {
 			if (ProviderEndpoint.PendingRequest == null) {
 				Response.Redirect("~/");
 			}
 
 			this.relyingPartyVerificationResultLabel.Text =
-				ProviderEndpoint.PendingRequest.IsReturnUrlDiscoverable(ProviderEndpoint.Provider.Channel.WebRequestHandler) == RelyingPartyDiscoveryResult.Success ? "passed" : "failed";
+				await ProviderEndpoint.PendingRequest.IsReturnUrlDiscoverableAsync() == RelyingPartyDiscoveryResult.Success ? "passed" : "failed";
 
 			this.realmLabel.Text = ProviderEndpoint.PendingRequest.Realm.ToString();
 
@@ -61,7 +62,7 @@ namespace OpenIdProviderWebForms {
 			}
 		}
 
-		protected void Yes_Click(object sender, EventArgs e) {
+		protected async void Yes_Click(object sender, EventArgs e) {
 			if (!Page.IsValid) {
 				return;
 			}
@@ -98,17 +99,19 @@ namespace OpenIdProviderWebForms {
 				ProviderEndpoint.PendingAnonymousRequest.IsApproved = true;
 			}
 			Debug.Assert(ProviderEndpoint.PendingRequest.IsResponseReady, "Setting authentication should be all that's necessary.");
-			ProviderEndpoint.SendResponse();
+			var response = await ProviderEndpoint.PrepareResponseAsync(this.Response.ClientDisconnectedToken);
+			await response.SendAsync();
 		}
 
-		protected void No_Click(object sender, EventArgs e) {
+		protected async void No_Click(object sender, EventArgs e) {
 			if (ProviderEndpoint.PendingAuthenticationRequest != null) {
 				ProviderEndpoint.PendingAuthenticationRequest.IsAuthenticated = false;
 			} else {
 				ProviderEndpoint.PendingAnonymousRequest.IsApproved = false;
 			}
 			Debug.Assert(ProviderEndpoint.PendingRequest.IsResponseReady, "Setting authentication should be all that's necessary.");
-			ProviderEndpoint.SendResponse();
+			var response = await ProviderEndpoint.PrepareResponseAsync(this.Response.ClientDisconnectedToken);
+			await response.SendAsync();
 		}
 	}
 }
\ No newline at end of file
diff --git a/samples/OpenIdProviderWebForms/decide.aspx.designer.cs b/samples/OpenIdProviderWebForms/decide.aspx.designer.cs
index 3aa6271..f40323c 100644
--- a/samples/OpenIdProviderWebForms/decide.aspx.designer.cs
+++ b/samples/OpenIdProviderWebForms/decide.aspx.designer.cs
@@ -1,10 +1,9 @@
 //------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
-//     Runtime Version:2.0.50727.4918
 //
 //     Changes to this file may cause incorrect behavior and will be lost if
-//     the code is regenerated.
+//     the code is regenerated. 
 // </auto-generated>
 //------------------------------------------------------------------------------
 
diff --git a/samples/OpenIdProviderWebForms/packages.config b/samples/OpenIdProviderWebForms/packages.config
index 6562527..8e40260 100644
--- a/samples/OpenIdProviderWebForms/packages.config
+++ b/samples/OpenIdProviderWebForms/packages.config
@@ -1,4 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="log4net" version="2.0.0" targetFramework="net45" />
+  <package id="Microsoft.Net.Http" version="2.0.20710.0" targetFramework="net45" />
 </packages>
\ No newline at end of file
diff --git a/src/DotNetOpenAuth.Core/Messaging/MessagingUtilities.cs b/src/DotNetOpenAuth.Core/Messaging/MessagingUtilities.cs
index b342611..947a971 100644
--- a/src/DotNetOpenAuth.Core/Messaging/MessagingUtilities.cs
+++ b/src/DotNetOpenAuth.Core/Messaging/MessagingUtilities.cs
@@ -385,22 +385,38 @@ namespace DotNetOpenAuth.Messaging {
 			return new HttpResponseMessageActionResult(response);
 		}
 
-		public static void Send(this HttpResponseMessage response, HttpContextBase context = null) {
+		public static async Task SendAsync(this HttpResponseMessage response, HttpResponseBase responseContext = null, CancellationToken cancellationToken = default(CancellationToken)) {
 			Requires.NotNull(response, "response");
-			context = context ?? new HttpContextWrapper(HttpContext.Current);
-			Verify.Operation(context != null, MessagingStrings.HttpContextRequired);
+			if (responseContext == null) {
+				ErrorUtilities.VerifyHttpContext();
+				responseContext = new HttpResponseWrapper(HttpContext.Current.Response);
+			}
 
-			context.Response.StatusCode = (int)response.StatusCode;
-			context.Response.StatusDescription = response.ReasonPhrase;
+			if (!cancellationToken.CanBeCanceled) {
+				cancellationToken = responseContext.ClientDisconnectedToken;
+			}
+
+			responseContext.StatusCode = (int)response.StatusCode;
+			responseContext.StatusDescription = response.ReasonPhrase;
 			foreach (var header in response.Headers) {
 				foreach (var value in header.Value) {
-					context.Response.AddHeader(header.Key, value);
+					responseContext.AddHeader(header.Key, value);
 				}
 			}
 
 			if (response.Content != null) {
-				response.Content.CopyToAsync(context.Response.OutputStream).Wait();
+				await response.Content.CopyToAsync(responseContext.OutputStream).ConfigureAwait(false);
+			}
+		}
+
+		public static void Send(this HttpResponseMessage response, HttpContextBase context = null) {
+			Requires.NotNull(response, "response");
+			if (context == null) {
+				ErrorUtilities.VerifyHttpContext();
+				context = new HttpContextWrapper(HttpContext.Current);
 			}
+
+			SendAsync(response, context.Response).GetAwaiter().GetResult();
 		}
 
 		internal static void DisposeIfNotNull(this IDisposable disposable) {