1 files changed, 24 insertions, 17 deletions

diff --git a/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/AssociationManager.cs b/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/AssociationManager.cs
index dfb307b..14566e1 100644
--- a/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/AssociationManager.cs
+++ b/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/AssociationManager.cs
@@ -11,6 +11,8 @@ namespace DotNetOpenAuth.OpenId.RelyingParty {
 	using System.Net;
 	using System.Security;
 	using System.Text;
+	using System.Threading;
+	using System.Threading.Tasks;
 	using DotNetOpenAuth.Messaging;
 	using DotNetOpenAuth.OpenId.ChannelElements;
 	using DotNetOpenAuth.OpenId.Messages;
@@ -131,8 +133,8 @@ namespace DotNetOpenAuth.OpenId.RelyingParty {
 		/// </summary>
 		/// <param name="provider">The provider to get an association for.</param>
 		/// <returns>The existing or new association; <c>null</c> if none existed and one could not be created.</returns>
-		internal Association GetOrCreateAssociation(IProviderEndpoint provider) {
-			return this.GetExistingAssociation(provider) ?? this.CreateNewAssociation(provider);
+		internal async Task<Association> GetOrCreateAssociationAsync(IProviderEndpoint provider, CancellationToken cancellationToken) {
+			return this.GetExistingAssociation(provider) ?? await this.CreateNewAssociationAsync(provider, cancellationToken);
 		}
 
 		/// <summary>
@@ -148,7 +150,7 @@ namespace DotNetOpenAuth.OpenId.RelyingParty {
 		/// association store.
 		/// Any new association is automatically added to the <see cref="associationStore"/>.
 		/// </remarks>
-		private Association CreateNewAssociation(IProviderEndpoint provider) {
+		private async Task<Association> CreateNewAssociationAsync(IProviderEndpoint provider, CancellationToken cancellationToken) {
 			Requires.NotNull(provider, "provider");
 
 			// If there is no association store, there is no point in creating an association.
@@ -160,7 +162,7 @@ namespace DotNetOpenAuth.OpenId.RelyingParty {
 				var associateRequest = AssociateRequestRelyingParty.Create(this.securitySettings, provider);
 
 				const int RenegotiateRetries = 1;
-				return this.CreateNewAssociation(provider, associateRequest, RenegotiateRetries);
+				return await this.CreateNewAssociationAsync(provider, associateRequest, RenegotiateRetries, cancellationToken);
 			} catch (VerificationException ex) {
 				// See Trac ticket #163.  In partial trust host environments, the
 				// Diffie-Hellman implementation we're using for HTTP OP endpoints
@@ -182,7 +184,7 @@ namespace DotNetOpenAuth.OpenId.RelyingParty {
 		/// The newly created association, or null if no association can be created with
 		/// the given Provider given the current security settings.
 		/// </returns>
-		private Association CreateNewAssociation(IProviderEndpoint provider, AssociateRequest associateRequest, int retriesRemaining) {
+		private async Task<Association> CreateNewAssociationAsync(IProviderEndpoint provider, AssociateRequest associateRequest, int retriesRemaining, CancellationToken cancellationToken) {
 			Requires.NotNull(provider, "provider");
 
 			if (associateRequest == null || retriesRemaining < 0) {
@@ -191,8 +193,9 @@ namespace DotNetOpenAuth.OpenId.RelyingParty {
 				return null;
 			}
 
+			Exception exception = null;
 			try {
-				var associateResponse = this.channel.Request(associateRequest);
+				var associateResponse = await this.channel.RequestAsync(associateRequest, cancellationToken);
 				var associateSuccessfulResponse = associateResponse as IAssociateSuccessfulResponseRelyingParty;
 				var associateUnsuccessfulResponse = associateResponse as AssociateUnsuccessfulResponse;
 				if (associateSuccessfulResponse != null) {
@@ -224,23 +227,27 @@ namespace DotNetOpenAuth.OpenId.RelyingParty {
 						associateUnsuccessfulResponse.SessionType);
 
 					associateRequest = AssociateRequestRelyingParty.Create(this.securitySettings, provider, associateUnsuccessfulResponse.AssociationType, associateUnsuccessfulResponse.SessionType);
-					return this.CreateNewAssociation(provider, associateRequest, retriesRemaining - 1);
+					return await this.CreateNewAssociationAsync(provider, associateRequest, retriesRemaining - 1, cancellationToken);
 				} else {
 					throw new ProtocolException(MessagingStrings.UnexpectedMessageReceivedOfMany);
 				}
 			} catch (ProtocolException ex) {
-				// If the association failed because the remote server can't handle Expect: 100 Continue headers,
-				// then our web request handler should have already accomodated for future calls.  Go ahead and
-				// immediately make one of those future calls now to try to get the association to succeed.
-				if (StandardWebRequestHandler.IsExceptionFrom417ExpectationFailed(ex)) {
-					return this.CreateNewAssociation(provider, associateRequest, retriesRemaining - 1);
-				}
+				exception = ex;
+			}
 
-				// Since having associations with OPs is not totally critical, we'll log and eat
-				// the exception so that auth may continue in dumb mode.
-				Logger.OpenId.ErrorFormat("An error occurred while trying to create an association with {0}.  {1}", provider.Uri, ex);
-				return null;
+			Assumes.NotNull(exception);
+
+			// If the association failed because the remote server can't handle Expect: 100 Continue headers,
+			// then our web request handler should have already accomodated for future calls.  Go ahead and
+			// immediately make one of those future calls now to try to get the association to succeed.
+			if (UntrustedWebRequestHandler.IsExceptionFrom417ExpectationFailed(exception)) {
+				return await this.CreateNewAssociationAsync(provider, associateRequest, retriesRemaining - 1, cancellationToken);
 			}
+
+			// Since having associations with OPs is not totally critical, we'll log and eat
+			// the exception so that auth may continue in dumb mode.
+			Logger.OpenId.ErrorFormat("An error occurred while trying to create an association with {0}.  {1}", provider.Uri, exception);
+			return null;
 		}
 	}
 }