diff --git a/projecttemplates/MvcRelyingParty/Controllers/AuthController.cs b/projecttemplates/MvcRelyingParty/Controllers/AuthController.cs index 1d9dadf1c0..35c39eaadb 100644 --- a/projecttemplates/MvcRelyingParty/Controllers/AuthController.cs +++ b/projecttemplates/MvcRelyingParty/Controllers/AuthController.cs @@ -210,6 +210,9 @@ public AuthController() /// /// Preloads discovery results for the OP buttons we display on the selector in the ViewData. /// + /// + /// A task that completes with the asynchronous operation. + /// private async Task PreloadDiscoveryResultsAsync() { this.ViewData["PreloadedDiscoveryResults"] = this.RelyingParty.PreloadDiscoveryResultsAsync( Realm.AutoDetect, diff --git a/samples/DotNetOpenAuth.ApplicationBlock/GoogleConsumer.cs b/samples/DotNetOpenAuth.ApplicationBlock/GoogleConsumer.cs index a6a6e9f838..631b495a71 100644 --- a/samples/DotNetOpenAuth.ApplicationBlock/GoogleConsumer.cs +++ b/samples/DotNetOpenAuth.ApplicationBlock/GoogleConsumer.cs @@ -177,9 +177,13 @@ public enum Applications : long /// /// Requests authorization from Google to access data from a set of Google applications. /// - /// The Google consumer previously constructed using or . + /// The Google consumer previously constructed using or . /// The requested access scope. /// The cancellation token. + /// + /// A task that completes with the asynchronous operation. + /// + /// consumer public static async Task RequestAuthorizationAsync(WebConsumer consumer, Applications requestedAccessScope, CancellationToken cancellationToken = default(CancellationToken)) { if (consumer == null) { throw new ArgumentNullException("consumer"); diff --git a/samples/OpenIdOfflineProvider/CheckIdWindow.xaml.cs b/samples/OpenIdOfflineProvider/CheckIdWindow.xaml.cs index 66bc109c8b..3e2750767f 100644 --- a/samples/OpenIdOfflineProvider/CheckIdWindow.xaml.cs +++ b/samples/OpenIdOfflineProvider/CheckIdWindow.xaml.cs @@ -55,6 +55,9 @@ public partial class CheckIdWindow : Window { /// /// The OpenID Provider host. /// The incoming authentication request. + /// + /// A task that completes with the asynchronous operation. + /// internal static async Task ProcessAuthenticationAsync(HostedProvider provider, IAuthenticationRequest request) { Requires.NotNull(provider, "provider"); Requires.NotNull(request, "request"); diff --git a/samples/OpenIdOfflineProvider/HostedProvider.cs b/samples/OpenIdOfflineProvider/HostedProvider.cs index a11c625691..1f41e9aed8 100644 --- a/samples/OpenIdOfflineProvider/HostedProvider.cs +++ b/samples/OpenIdOfflineProvider/HostedProvider.cs @@ -210,6 +210,9 @@ internal class HostedProvider : IDisposable { /// Handles incoming HTTP requests. /// /// The HttpListener context. + /// + /// A task that completes with the asynchronous operation. + /// private async Task RequestHandlerAsync(HttpListenerContext context) { Requires.NotNull(context, "context"); Requires.NotNull(context.Response.OutputStream, "context.Response.OutputStream"); diff --git a/samples/OpenIdOfflineProvider/HttpHost.cs b/samples/OpenIdOfflineProvider/HttpHost.cs index 242a8d3155..335d6776c0 100644 --- a/samples/OpenIdOfflineProvider/HttpHost.cs +++ b/samples/OpenIdOfflineProvider/HttpHost.cs @@ -65,6 +65,7 @@ internal class HttpHost : IDisposable { /// The request handler delegate. /// /// Information on the incoming HTTP request. + /// A task that completes with the async operation. internal delegate Task RequestHandlerAsync(HttpListenerContext context); /// @@ -117,6 +118,9 @@ internal class HttpHost : IDisposable { /// /// The HTTP listener thread body. /// + /// + /// A task that completes with the asynchronous operation. + /// private async Task ProcessRequestsAsync() { Assumes.True(this.listener != null); diff --git a/samples/OpenIdOfflineProvider/MainWindow.xaml.cs b/samples/OpenIdOfflineProvider/MainWindow.xaml.cs index ad96eddb83..b5d78910df 100644 --- a/samples/OpenIdOfflineProvider/MainWindow.xaml.cs +++ b/samples/OpenIdOfflineProvider/MainWindow.xaml.cs @@ -128,6 +128,9 @@ public partial class MainWindow : Window, IDisposable { /// /// The request info. /// The response. + /// + /// A task that completes with the asynchronous operation. + /// private async Task ProcessRequestAsync(HttpRequestBase requestInfo, HttpListenerResponse response) { IRequest request = await this.hostedProvider.Provider.GetRequestAsync(requestInfo, CancellationToken.None); if (request == null) { diff --git a/src/DotNetOpenAuth.AspNet/Clients/OAuth/DotNetOpenAuthWebConsumer.cs b/src/DotNetOpenAuth.AspNet/Clients/OAuth/DotNetOpenAuthWebConsumer.cs index a87a678c4b..09a56a8f68 100644 --- a/src/DotNetOpenAuth.AspNet/Clients/OAuth/DotNetOpenAuthWebConsumer.cs +++ b/src/DotNetOpenAuth.AspNet/Clients/OAuth/DotNetOpenAuthWebConsumer.cs @@ -68,7 +68,10 @@ public class DotNetOpenAuthWebConsumer : IOAuthWebWorker, IDisposable { /// /// The process user authorization. /// - /// The response message. + /// + /// + /// The response message. + /// public Task ProcessUserAuthorizationAsync(CancellationToken cancellationToken = default(CancellationToken)) { return this.webConsumer.ProcessUserAuthorizationAsync(cancellationToken: cancellationToken); } @@ -76,9 +79,11 @@ public class DotNetOpenAuthWebConsumer : IOAuthWebWorker, IDisposable { /// /// The request authentication. /// - /// - /// The callback. - /// + /// The callback. + /// The cancellation token. + /// + /// The response message. + /// public async Task RequestAuthenticationAsync(Uri callback, CancellationToken cancellationToken = default(CancellationToken)) { var redirectParameters = new Dictionary(); UserAuthorizationRequest request = await this.webConsumer.PrepareRequestUserAuthorizationAsync( diff --git a/src/DotNetOpenAuth.AspNet/Clients/OAuth/IOAuthWebWorker.cs b/src/DotNetOpenAuth.AspNet/Clients/OAuth/IOAuthWebWorker.cs index 91fca59402..205d4c01be 100644 --- a/src/DotNetOpenAuth.AspNet/Clients/OAuth/IOAuthWebWorker.cs +++ b/src/DotNetOpenAuth.AspNet/Clients/OAuth/IOAuthWebWorker.cs @@ -33,7 +33,10 @@ public interface IOAuthWebWorker { /// /// The process user authorization. /// - /// The response message. + /// The cancellation token. + /// + /// The response message. + /// Task ProcessUserAuthorizationAsync(CancellationToken cancellationToken = default(CancellationToken)); /// @@ -41,6 +44,7 @@ public interface IOAuthWebWorker { /// /// The callback. /// The cancellation token. + /// The response message Task RequestAuthenticationAsync(Uri callback, CancellationToken cancellationToken = default(CancellationToken)); #endregion diff --git a/src/DotNetOpenAuth.AspNet/Clients/OAuth/InMemoryOAuthTokenManager.cs b/src/DotNetOpenAuth.AspNet/Clients/OAuth/InMemoryOAuthTokenManager.cs index a7b641c2e3..e5fd67feed 100644 --- a/src/DotNetOpenAuth.AspNet/Clients/OAuth/InMemoryOAuthTokenManager.cs +++ b/src/DotNetOpenAuth.AspNet/Clients/OAuth/InMemoryOAuthTokenManager.cs @@ -92,9 +92,9 @@ public sealed class InMemoryOAuthTokenManager : IConsumerTokenManager { /// useful in an ASP.NET web application within the implementation of this method. /// Alternatively you may store the access token here without associating with a user account, /// and wait until - /// + /// /// or - /// + /// /// return the access /// token to associate the access token with a user account at that point. /// diff --git a/src/DotNetOpenAuth.AspNet/Clients/OAuth/LinkedInClient.cs b/src/DotNetOpenAuth.AspNet/Clients/OAuth/LinkedInClient.cs index 2445db5597..8128cbb056 100644 --- a/src/DotNetOpenAuth.AspNet/Clients/OAuth/LinkedInClient.cs +++ b/src/DotNetOpenAuth.AspNet/Clients/OAuth/LinkedInClient.cs @@ -82,11 +82,10 @@ public LinkedInClient(string consumerKey, string consumerSecret, IOAuthTokenMana /// /// Check if authentication succeeded after user is redirected back from the service provider. /// - /// - /// The response token returned from service provider - /// + /// The response token returned from service provider + /// The cancellation token. /// - /// Authentication result. + /// Authentication result. /// [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We don't care if the request fails.")] diff --git a/src/DotNetOpenAuth.AspNet/Clients/OAuth/OAuthClient.cs b/src/DotNetOpenAuth.AspNet/Clients/OAuth/OAuthClient.cs index fb6ba3d30d..ffe5c077eb 100644 --- a/src/DotNetOpenAuth.AspNet/Clients/OAuth/OAuthClient.cs +++ b/src/DotNetOpenAuth.AspNet/Clients/OAuth/OAuthClient.cs @@ -108,6 +108,9 @@ public abstract class OAuthClient : IAuthenticationClient { /// The context. /// The return url after users have completed authenticating against external website. /// The cancellation token. + /// + /// A task that completes with the asynchronous operation. + /// public virtual Task RequestAuthenticationAsync(HttpContextBase context, Uri returnUrl, CancellationToken cancellationToken = default(CancellationToken)) { Requires.NotNull(returnUrl, "returnUrl"); Requires.NotNull(context, "context"); diff --git a/src/DotNetOpenAuth.AspNet/Clients/OAuth2/OAuth2Client.cs b/src/DotNetOpenAuth.AspNet/Clients/OAuth2/OAuth2Client.cs index 317a46da70..c9bfafc02e 100644 --- a/src/DotNetOpenAuth.AspNet/Clients/OAuth2/OAuth2Client.cs +++ b/src/DotNetOpenAuth.AspNet/Clients/OAuth2/OAuth2Client.cs @@ -62,6 +62,9 @@ public abstract class OAuth2Client : IAuthenticationClient { /// The context. /// The return url after users have completed authenticating against external website. /// The cancellation token. + /// + /// A task that completes with the asynchronous operation. + /// public virtual async Task RequestAuthenticationAsync(HttpContextBase context, Uri returnUrl, CancellationToken cancellationToken = default(CancellationToken)) { Requires.NotNull(context, "context"); Requires.NotNull(returnUrl, "returnUrl"); @@ -90,7 +93,7 @@ public abstract class OAuth2Client : IAuthenticationClient { /// The return URL which should match the value passed to RequestAuthentication() method. /// The cancellation token. /// - /// An instance of containing authentication result. + /// An instance of containing authentication result. /// public virtual async Task VerifyAuthenticationAsync(HttpContextBase context, Uri returnPageUrl, CancellationToken cancellationToken = default(CancellationToken)) { Requires.NotNull(context, "context"); diff --git a/src/DotNetOpenAuth.AspNet/Clients/OpenID/OpenIDClient.cs b/src/DotNetOpenAuth.AspNet/Clients/OpenID/OpenIDClient.cs index 0d6d6ca55a..68ea20fb51 100644 --- a/src/DotNetOpenAuth.AspNet/Clients/OpenID/OpenIDClient.cs +++ b/src/DotNetOpenAuth.AspNet/Clients/OpenID/OpenIDClient.cs @@ -81,13 +81,12 @@ public class OpenIdClient : IAuthenticationClient { /// /// Attempts to authenticate users by forwarding them to an external website, and upon succcess or failure, redirect users back to the specified url. /// - /// - /// The context of the current request. - /// - /// - /// The return url after users have completed authenticating against external website. - /// + /// The context of the current request. + /// The return url after users have completed authenticating against external website. /// The cancellation token. + /// + /// A task that completes with the asynchronous operation. + /// [SuppressMessage("Microsoft.Usage", "CA2234:PassSystemUriObjectsInsteadOfStrings", Justification = "We don't have a Uri object handy.")] public virtual async Task RequestAuthenticationAsync(HttpContextBase context, Uri returnUrl, CancellationToken cancellationToken = default(CancellationToken)) { diff --git a/src/DotNetOpenAuth.AspNet/OpenAuthSecurityManager.cs b/src/DotNetOpenAuth.AspNet/OpenAuthSecurityManager.cs index 794ba10ede..7669072a3d 100644 --- a/src/DotNetOpenAuth.AspNet/OpenAuthSecurityManager.cs +++ b/src/DotNetOpenAuth.AspNet/OpenAuthSecurityManager.cs @@ -143,9 +143,11 @@ public class OpenAuthSecurityManager { /// /// Requests the specified provider to start the authentication by directing users to an external website /// - /// - /// The return url after user is authenticated. - /// + /// The return url after user is authenticated. + /// The cancellation token. + /// + /// A task that completes with the asynchronous operation. + /// public async Task RequestAuthenticationAsync(string returnUrl, CancellationToken cancellationToken = default(CancellationToken)) { // convert returnUrl to an absolute path Uri uri; @@ -185,12 +187,13 @@ public class OpenAuthSecurityManager { /// Checks if user is successfully authenticated when user is redirected back to this user. /// /// The return Url which must match exactly the Url passed into RequestAuthentication() earlier. - /// - /// This returnUrl parameter only applies to OAuth2 providers. For other providers, it ignores the returnUrl parameter. - /// + /// The cancellation token. /// /// The result of the authentication. /// + /// + /// This returnUrl parameter only applies to OAuth2 providers. For other providers, it ignores the returnUrl parameter. + /// public async Task VerifyAuthenticationAsync(string returnUrl, CancellationToken cancellationToken = default(CancellationToken)) { // check for XSRF attack string sessionId; diff --git a/src/DotNetOpenAuth.Core/Messaging/Channel.cs b/src/DotNetOpenAuth.Core/Messaging/Channel.cs index 0dc31b8de8..6aaf8ea879 100644 --- a/src/DotNetOpenAuth.Core/Messaging/Channel.cs +++ b/src/DotNetOpenAuth.Core/Messaging/Channel.cs @@ -387,7 +387,10 @@ public async Task ReadFromRequestAsync(CancellationToken can /// Gets the protocol message that may be embedded in the given HTTP request. /// /// The request to search for an embedded message. - /// The deserialized message, if one is found. Null otherwise. + /// The cancellation token. + /// + /// The deserialized message, if one is found. Null otherwise. + /// public async Task ReadFromRequestAsync(HttpRequestBase httpRequest, CancellationToken cancellationToken) { Requires.NotNull(httpRequest, "httpRequest"); @@ -476,10 +479,11 @@ public async Task RequestAsync(IDirectedProtocolMessage re /// /// The message just received. /// The cancellation token. - /// - /// Thrown when the message is somehow invalid. - /// This can be due to tampering, replay attack or expiration, among other things. - /// + /// + /// A task that completes with the asynchronous operation. + /// + /// Thrown when the message is somehow invalid. + /// This can be due to tampering, replay attack or expiration, among other things. internal Task ProcessIncomingMessageTestHookAsync(IProtocolMessage message, CancellationToken cancellationToken) { return this.ProcessIncomingMessageAsync(message, cancellationToken); } @@ -525,7 +529,9 @@ public async Task RequestAsync(IDirectedProtocolMessage re /// /// The message to prepare for sending. /// The cancellation token. - /// + /// + /// A task that completes with the asynchronous operation. + /// /// /// This method should NOT be called by derived types /// except when sending ONE WAY request messages. @@ -962,7 +968,9 @@ public async Task RequestAsync(IDirectedProtocolMessage re /// /// The message to prepare for sending. /// The cancellation token. - /// + /// + /// A task that completes with the asynchronous operation. + /// /// /// /// This method should NOT be called by derived types @@ -1134,10 +1142,12 @@ public async Task RequestAsync(IDirectedProtocolMessage re /// /// The message just received. /// The cancellation token. - /// - /// Thrown when the message is somehow invalid. - /// This can be due to tampering, replay attack or expiration, among other things. - /// + /// + /// A task that completes with the asynchronous operation. + /// + /// + /// Thrown when the message is somehow invalid. + /// This can be due to tampering, replay attack or expiration, among other things. protected virtual async Task ProcessIncomingMessageAsync(IProtocolMessage message, CancellationToken cancellationToken) { Requires.NotNull(message, "message"); diff --git a/src/DotNetOpenAuth.Core/Reporting.cs b/src/DotNetOpenAuth.Core/Reporting.cs index 20aeddcb2e..432a833b96 100644 --- a/src/DotNetOpenAuth.Core/Reporting.cs +++ b/src/DotNetOpenAuth.Core/Reporting.cs @@ -370,6 +370,7 @@ public class Reporting { /// /// Creates an HTTP client that can be used for outbound HTTP requests. /// + /// The HTTP client to use. private static HttpClient CreateHttpClient() { var channel = new HttpClientHandler(); channel.AllowAutoRedirect = false; diff --git a/src/DotNetOpenAuth.Core/Util.cs b/src/DotNetOpenAuth.Core/Util.cs index 346380899b..ebbaaa46e1 100644 --- a/src/DotNetOpenAuth.Core/Util.cs +++ b/src/DotNetOpenAuth.Core/Util.cs @@ -235,7 +235,7 @@ internal static class Util { /// The type of the result. /// The source. /// The transform. - /// + /// A dictionary populated with the results of the transforms. internal static async Task> ToDictionaryAsync( this IEnumerable source, Func> transform) { var taskResults = source.ToDictionary(s => s, transform); diff --git a/src/DotNetOpenAuth.OAuth.Consumer/OAuth/OAuth1HttpMessageHandler.cs b/src/DotNetOpenAuth.OAuth.Consumer/OAuth/OAuth1HttpMessageHandler.cs index cfbb70ea26..a763d5eb14 100644 --- a/src/DotNetOpenAuth.OAuth.Consumer/OAuth/OAuth1HttpMessageHandler.cs +++ b/src/DotNetOpenAuth.OAuth.Consumer/OAuth/OAuth1HttpMessageHandler.cs @@ -1,4 +1,10 @@ -namespace DotNetOpenAuth.OAuth { +//----------------------------------------------------------------------- +// +// Copyright (c) Andrew Arnott. All rights reserved. +// +//----------------------------------------------------------------------- + +namespace DotNetOpenAuth.OAuth { using System; using System.Collections.Generic; using System.Linq; @@ -11,6 +17,9 @@ using Validation; + /// + /// A delegated HTTP handler that automatically signs outgoing requests. + /// public class OAuth1HttpMessageHandler : DelegatingHandler { /// /// Initializes a new instance of the class. @@ -34,10 +43,30 @@ public OAuth1HttpMessageHandler(HttpMessageHandler innerHandler, ConsumerBase co this.AccessToken = accessToken; } + /// + /// Gets or sets the access token. + /// + /// + /// The access token. + /// public string AccessToken { get; set; } + /// + /// Gets or sets the consumer. + /// + /// + /// The consumer. + /// public ConsumerBase Consumer { get; set; } + /// + /// Sends an HTTP request to the inner handler to send to the server as an asynchronous operation. + /// + /// The HTTP request message to send to the server. + /// A cancellation token to cancel operation. + /// + /// Returns . The task object representing the asynchronous operation. + /// protected override async Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { Verify.Operation(this.Consumer != null, Strings.RequiredPropertyNotYetPreset, "Consumer"); Verify.Operation(!string.IsNullOrEmpty(this.AccessToken), Strings.RequiredPropertyNotYetPreset, "AccessToken"); diff --git a/src/DotNetOpenAuth.OAuth.ServiceProvider/OAuth/ServiceProvider.cs b/src/DotNetOpenAuth.OAuth.ServiceProvider/OAuth/ServiceProvider.cs index 71621e13fa..de7ff7c01c 100644 --- a/src/DotNetOpenAuth.OAuth.ServiceProvider/OAuth/ServiceProvider.cs +++ b/src/DotNetOpenAuth.OAuth.ServiceProvider/OAuth/ServiceProvider.cs @@ -151,6 +151,8 @@ public ServiceProvider(ServiceProviderDescription serviceDescription, IServicePr /// Gets the standard state storage mechanism that uses ASP.NET's /// HttpApplication state dictionary to store associations and nonces. /// + /// The HTTP context. If null, this method must be called while is non-null. + /// The nonce store. public static INonceStore GetHttpApplicationStore(HttpContextBase context = null) { if (context == null) { ErrorUtilities.VerifyOperation(HttpContext.Current != null, Strings.StoreRequiredWhenNoHttpContextAvailable, typeof(INonceStore).Name); @@ -203,7 +205,11 @@ public ServiceProvider(ServiceProviderDescription serviceDescription, IServicePr /// /// Reads any incoming OAuth message. /// - /// The deserialized message. + /// The request. + /// The cancellation token. + /// + /// The deserialized message. + /// /// /// Requires HttpContext.Current. /// diff --git a/src/DotNetOpenAuth.OAuth/OAuth/Messages/UserAuthorizationRequest.cs b/src/DotNetOpenAuth.OAuth/OAuth/Messages/UserAuthorizationRequest.cs index 357220bee0..fd634da6b9 100644 --- a/src/DotNetOpenAuth.OAuth/OAuth/Messages/UserAuthorizationRequest.cs +++ b/src/DotNetOpenAuth.OAuth/OAuth/Messages/UserAuthorizationRequest.cs @@ -62,7 +62,7 @@ internal UserAuthorizationRequest(MessageReceivingEndpoint serviceProvider, Vers } /// - /// Gets or sets the Request Token obtained in the previous step. + /// Gets the Request Token obtained in the previous step. /// /// /// The Service Provider MAY declare this parameter as REQUIRED, or diff --git a/src/DotNetOpenAuth.OAuth2.AuthorizationServer/OAuth2/ChannelElements/MessageValidationBindingElement.cs b/src/DotNetOpenAuth.OAuth2.AuthorizationServer/OAuth2/ChannelElements/MessageValidationBindingElement.cs index 6e789552b2..25720f6c0b 100644 --- a/src/DotNetOpenAuth.OAuth2.AuthorizationServer/OAuth2/ChannelElements/MessageValidationBindingElement.cs +++ b/src/DotNetOpenAuth.OAuth2.AuthorizationServer/OAuth2/ChannelElements/MessageValidationBindingElement.cs @@ -84,7 +84,7 @@ internal class MessageValidationBindingElement : AuthServerBindingElementBase { /// The protections (if any) that this binding element applied to the message. /// Null if this binding element did not even apply to this binding element. /// - /// + /// Thrown when an authorization or protocol rule is violated. /// Thrown when the binding element rules indicate that this message is invalid and should /// NOT be processed. /// diff --git a/src/DotNetOpenAuth.OAuth2.Client.UI/OAuth2/ClientAuthorizationView.cs b/src/DotNetOpenAuth.OAuth2.Client.UI/OAuth2/ClientAuthorizationView.cs index 8f27ae6ff3..002202eac3 100644 --- a/src/DotNetOpenAuth.OAuth2.Client.UI/OAuth2/ClientAuthorizationView.cs +++ b/src/DotNetOpenAuth.OAuth2.Client.UI/OAuth2/ClientAuthorizationView.cs @@ -143,6 +143,9 @@ public partial class ClientAuthorizationView : UserControl { /// Processes changes in the URL the browser has navigated to. /// /// The location. + /// + /// A task that completes with the asynchronous operation. + /// private async Task ProcessLocationChangedAsync(Uri location) { if (SignificantlyEqual(location, this.Authorization.Callback, UriComponents.SchemeAndServer | UriComponents.Path)) { try { diff --git a/src/DotNetOpenAuth.OAuth2.Client/OAuth2/ClientBase.cs b/src/DotNetOpenAuth.OAuth2.Client/OAuth2/ClientBase.cs index bf56586537..ea5dcf5569 100644 --- a/src/DotNetOpenAuth.OAuth2.Client/OAuth2/ClientBase.cs +++ b/src/DotNetOpenAuth.OAuth2.Client/OAuth2/ClientBase.cs @@ -118,6 +118,9 @@ public class ClientBase { /// The request for protected resources from the service provider. /// The authorization for this request previously obtained via OAuth. /// The cancellation token. + /// + /// A task that completes with the asynchronous operation. + /// public Task AuthorizeRequestAsync(HttpWebRequest request, IAuthorizationState authorization, CancellationToken cancellationToken) { Requires.NotNull(request, "request"); Requires.NotNull(authorization, "authorization"); @@ -132,6 +135,9 @@ public class ClientBase { /// The headers on the request for protected resources from the service provider. /// The authorization for this request previously obtained via OAuth. /// The cancellation token. + /// + /// A task that completes with the asynchronous operation. + /// public async Task AuthorizeRequestAsync(WebHeaderCollection requestHeaders, IAuthorizationState authorization, CancellationToken cancellationToken) { Requires.NotNull(requestHeaders, "requestHeaders"); Requires.NotNull(authorization, "authorization"); @@ -334,6 +340,9 @@ public class ClientBase { /// The authorization state to update. /// The authorization success message obtained from the authorization server. /// The cancellation token. + /// + /// A task that completes with the asynchronous operation. + /// internal async Task UpdateAuthorizationWithResponseAsync(IAuthorizationState authorizationState, EndUserAuthorizationSuccessAuthCodeResponse authorizationSuccess, CancellationToken cancellationToken) { Requires.NotNull(authorizationState, "authorizationState"); Requires.NotNull(authorizationSuccess, "authorizationSuccess"); diff --git a/src/DotNetOpenAuth.OpenId.Provider.UI/OpenId/Provider/ProviderEndpoint.cs b/src/DotNetOpenAuth.OpenId.Provider.UI/OpenId/Provider/ProviderEndpoint.cs index 3213206dab..65086d7b1b 100644 --- a/src/DotNetOpenAuth.OpenId.Provider.UI/OpenId/Provider/ProviderEndpoint.cs +++ b/src/DotNetOpenAuth.OpenId.Provider.UI/OpenId/Provider/ProviderEndpoint.cs @@ -175,8 +175,12 @@ public class ProviderEndpoint : Control { } /// - /// Sends the response for the and clears the property. + /// Sends the response for the and clears the property. /// + /// The cancellation token. + /// + /// The response message. + /// public static Task PrepareResponseAsync(CancellationToken cancellationToken = default(CancellationToken)) { var pendingRequest = PendingRequest; PendingRequest = null; diff --git a/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/AnonymousRequest.cs b/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/AnonymousRequest.cs index 23d1e3c097..ecb8a40f0d 100644 --- a/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/AnonymousRequest.cs +++ b/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/AnonymousRequest.cs @@ -77,8 +77,10 @@ internal AnonymousRequest(OpenIdProvider provider, SignedResponseRequest request } /// - /// Gets the response message, once is true. + /// Gets the response message, once is true. /// + /// The cancellation token. + /// The response message. protected override async Task GetResponseMessageAsync(CancellationToken cancellationToken) { if (this.IsApproved.HasValue) { return this.IsApproved.Value ? (IProtocolMessage)this.positiveResponse : (await this.GetNegativeResponseAsync()); diff --git a/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/AuthenticationRequest.cs b/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/AuthenticationRequest.cs index 80d8aeb2ef..7d66ff81de 100644 --- a/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/AuthenticationRequest.cs +++ b/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/AuthenticationRequest.cs @@ -214,8 +214,10 @@ internal AuthenticationRequest(OpenIdProvider provider, CheckIdRequest request) } /// - /// Gets the response message, once is true. + /// Gets the response message, once is true. /// + /// The cancellation token. + /// The response message. protected override async Task GetResponseMessageAsync(CancellationToken cancellationToken) { if (this.IsAuthenticated.HasValue) { return this.IsAuthenticated.Value ? (IProtocolMessage)this.positiveResponse : (await this.GetNegativeResponseAsync()); diff --git a/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/AutoResponsiveRequest.cs b/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/AutoResponsiveRequest.cs index d9ed0537a9..82b3f2ee7a 100644 --- a/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/AutoResponsiveRequest.cs +++ b/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/AutoResponsiveRequest.cs @@ -64,15 +64,20 @@ internal AutoResponsiveRequest(IProtocolMessage response, ProviderSecuritySettin } /// - /// Gets the response message, once is true. + /// Gets the response message, once is true. /// + /// The response message. internal Task GetResponseMessageAsyncTestHook() { return this.GetResponseMessageAsync(CancellationToken.None); } /// - /// Gets the response message, once is true. + /// Gets the response message, once is true. /// + /// The cancellation token. + /// + /// The response message. + /// protected override Task GetResponseMessageAsync(CancellationToken cancellationToken) { return Task.FromResult(this.response); } diff --git a/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/Extensions/ExtensionsInteropHelper.cs b/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/Extensions/ExtensionsInteropHelper.cs index a275647036..aedf1190cb 100644 --- a/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/Extensions/ExtensionsInteropHelper.cs +++ b/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/Extensions/ExtensionsInteropHelper.cs @@ -77,6 +77,9 @@ internal static class ExtensionsInteropHelper { /// /// The authentication request with the response extensions already added. /// The cancellation token. + /// + /// A task that completes with the asynchronous operation. + /// /// /// If the original attribute request came in as AX, the Simple Registration extension is converted /// to an AX response and then the Simple Registration extension is removed from the response. diff --git a/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/HostProcessedRequest.cs b/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/HostProcessedRequest.cs index 07807d22a2..c4c2674eaf 100644 --- a/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/HostProcessedRequest.cs +++ b/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/HostProcessedRequest.cs @@ -178,6 +178,7 @@ protected HostProcessedRequest(OpenIdProvider provider, SignedResponseRequest re /// /// Gets the negative response. /// + /// The negative assertion message. protected Task GetNegativeResponseAsync() { return this.negativeResponse.Value; } diff --git a/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/OpenIdProvider.cs b/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/OpenIdProvider.cs index 049529969f..3b44e59107 100644 --- a/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/OpenIdProvider.cs +++ b/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/OpenIdProvider.cs @@ -176,6 +176,8 @@ public OpenIdProvider(IOpenIdApplicationStore applicationStore) /// Gets the standard state storage mechanism that uses ASP.NET's /// HttpApplication state dictionary to store associations and nonces. /// + /// The context. + /// The application store. public static IOpenIdApplicationStore GetHttpApplicationStore(HttpContextBase context = null) { if (context == null) { ErrorUtilities.VerifyOperation(HttpContext.Current != null, Strings.StoreRequiredWhenNoHttpContextAvailable, typeof(IOpenIdApplicationStore).Name); @@ -421,7 +423,9 @@ public OpenIdProvider(IOpenIdApplicationStore applicationStore) /// /// The request. /// The cancellation token. - /// + /// + /// A task that completes with the asynchronous operation. + /// private async Task ApplyBehaviorsToResponseAsync(IRequest request, CancellationToken cancellationToken) { var authRequest = request as IAuthenticationRequest; if (authRequest != null) { diff --git a/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/Request.cs b/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/Request.cs index cc443389c5..b937be98f8 100644 --- a/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/Request.cs +++ b/src/DotNetOpenAuth.OpenId.Provider/OpenId/Provider/Request.cs @@ -203,9 +203,10 @@ internal abstract class Request : IRequest { } /// - /// Gets the response message, once is true. + /// Gets the response message, once is true. /// /// The cancellation token. + /// The response message. protected abstract Task GetResponseMessageAsync(CancellationToken cancellationToken); } } diff --git a/src/DotNetOpenAuth.OpenId.RelyingParty.UI/OpenId/RelyingParty/OpenIdAjaxRelyingParty.cs b/src/DotNetOpenAuth.OpenId.RelyingParty.UI/OpenId/RelyingParty/OpenIdAjaxRelyingParty.cs index a08c323c47..cef5017a30 100644 --- a/src/DotNetOpenAuth.OpenId.RelyingParty.UI/OpenId/RelyingParty/OpenIdAjaxRelyingParty.cs +++ b/src/DotNetOpenAuth.OpenId.RelyingParty.UI/OpenId/RelyingParty/OpenIdAjaxRelyingParty.cs @@ -258,7 +258,10 @@ public OpenIdAjaxRelyingParty(IOpenIdApplicationStore applicationStore) /// The authentication request. /// trueto create a checkid_immediate request; /// false to create a checkid_setup request. - /// The absolute URL that carries the entire OpenID message. + /// The cancellation token. + /// + /// The absolute URL that carries the entire OpenID message. + /// private async Task GetRedirectUrlAsync(IAuthenticationRequest request, bool immediate, CancellationToken cancellationToken) { Requires.NotNull(request, "request"); diff --git a/src/DotNetOpenAuth.OpenId.RelyingParty.UI/OpenId/RelyingParty/OpenIdRelyingPartyAjaxControlBase.cs b/src/DotNetOpenAuth.OpenId.RelyingParty.UI/OpenId/RelyingParty/OpenIdRelyingPartyAjaxControlBase.cs index 56b354e606..9ad53b840c 100644 --- a/src/DotNetOpenAuth.OpenId.RelyingParty.UI/OpenId/RelyingParty/OpenIdRelyingPartyAjaxControlBase.cs +++ b/src/DotNetOpenAuth.OpenId.RelyingParty.UI/OpenId/RelyingParty/OpenIdRelyingPartyAjaxControlBase.cs @@ -195,6 +195,7 @@ public abstract class OpenIdRelyingPartyAjaxControlBase : OpenIdRelyingPartyCont /// Gets the completed authentication response. /// /// The cancellation token. + /// The response message. public async Task GetAuthenticationResponseAsync(CancellationToken cancellationToken) { if (this.authenticationResponse == null) { // We will either validate a new response and return a live AuthenticationResponse @@ -312,7 +313,9 @@ public abstract class OpenIdRelyingPartyAjaxControlBase : OpenIdRelyingPartyCont /// /// The identifier. /// The cancellation token. - /// + /// + /// A task that completes with the asynchronous operation. + /// protected Task PreloadDiscoveryAsync(Identifier identifier, CancellationToken cancellationToken) { return this.PreloadDiscoveryAsync(new[] { identifier }, cancellationToken); } @@ -323,7 +326,9 @@ public abstract class OpenIdRelyingPartyAjaxControlBase : OpenIdRelyingPartyCont /// /// The identifiers to perform discovery on. /// The cancellation token. - /// + /// + /// A task that completes with the asynchronous operation. + /// protected async Task PreloadDiscoveryAsync(IEnumerable identifiers, CancellationToken cancellationToken) { var requests = await Task.WhenAll(identifiers.Select(id => this.CreateRequestsAsync(id, cancellationToken))); string script = await this.AjaxRelyingParty.AsAjaxPreloadedDiscoveryResultAsync(requests.SelectMany(r => r), cancellationToken); @@ -426,6 +431,9 @@ public abstract class OpenIdRelyingPartyAjaxControlBase : OpenIdRelyingPartyCont /// Notifies the user agent via an AJAX response of a completed authentication attempt. /// /// The cancellation token. + /// + /// A task that completes with the asynchronous operation. + /// protected override async Task ScriptClosingPopupOrIFrameAsync(CancellationToken cancellationToken) { Action callback = status => { if (status == AuthenticationStatus.Authenticated) { diff --git a/src/DotNetOpenAuth.OpenId.RelyingParty.UI/OpenId/RelyingParty/OpenIdRelyingPartyControlBase.cs b/src/DotNetOpenAuth.OpenId.RelyingParty.UI/OpenId/RelyingParty/OpenIdRelyingPartyControlBase.cs index f527cee4da..6026d1a6c0 100644 --- a/src/DotNetOpenAuth.OpenId.RelyingParty.UI/OpenId/RelyingParty/OpenIdRelyingPartyControlBase.cs +++ b/src/DotNetOpenAuth.OpenId.RelyingParty.UI/OpenId/RelyingParty/OpenIdRelyingPartyControlBase.cs @@ -514,7 +514,9 @@ public abstract class OpenIdRelyingPartyControlBase : Control, IPostBackEventHan /// provided in the text box. /// /// The cancellation token. - /// + /// + /// A task that completes with the asynchronous operation. + /// public async Task LogOnAsync(CancellationToken cancellationToken) { IAuthenticationRequest request = (await this.CreateRequestsAsync(cancellationToken)).FirstOrDefault(); ErrorUtilities.VerifyProtocol(request != null, OpenIdStrings.OpenIdEndpointNotFound); diff --git a/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/AuthenticationRequest.cs b/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/AuthenticationRequest.cs index a26b49ee42..6298f9c302 100644 --- a/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/AuthenticationRequest.cs +++ b/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/AuthenticationRequest.cs @@ -189,6 +189,9 @@ internal class AuthenticationRequest : IAuthenticationRequest { /// to redirect it to the OpenID Provider to start the OpenID authentication process. /// /// The cancellation token. + /// + /// The response message that will cause the client to redirect to the Provider. + /// public async Task GetRedirectingResponseAsync(CancellationToken cancellationToken) { foreach (var behavior in this.RelyingParty.Behaviors) { behavior.OnOutgoingAuthenticationRequest(this); diff --git a/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/ISetupRequiredAuthenticationResponse.cs b/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/ISetupRequiredAuthenticationResponse.cs index 4fc459fc4c..af36a00c43 100644 --- a/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/ISetupRequiredAuthenticationResponse.cs +++ b/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/ISetupRequiredAuthenticationResponse.cs @@ -6,6 +6,7 @@ namespace DotNetOpenAuth.OpenId.RelyingParty { using System; + using System.Threading; /// /// An interface to expose useful properties and functionality for handling @@ -14,7 +15,7 @@ namespace DotNetOpenAuth.OpenId.RelyingParty { /// public interface ISetupRequiredAuthenticationResponse { /// - /// Gets the to pass to + /// Gets the to pass to /// in a subsequent authentication attempt. /// Identifier UserSuppliedIdentifier { get; } diff --git a/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/NegativeAuthenticationResponse.cs b/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/NegativeAuthenticationResponse.cs index bf52060475..79fc5de060 100644 --- a/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/NegativeAuthenticationResponse.cs +++ b/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/NegativeAuthenticationResponse.cs @@ -8,6 +8,7 @@ namespace DotNetOpenAuth.OpenId.RelyingParty { using System; using System.Collections.Generic; using System.Linq; + using System.Threading.Tasks; using System.Web; using DotNetOpenAuth.Messaging; using DotNetOpenAuth.OpenId.Messages; @@ -126,10 +127,9 @@ internal class NegativeAuthenticationResponse : IAuthenticationResponse, ISetupR #region ISetupRequiredAuthenticationResponse Members /// - /// Gets the to pass to + /// Gets the to pass to /// in a subsequent authentication attempt. /// - /// public Identifier UserSuppliedIdentifier { get { ErrorUtilities.VerifyOperation(((IAuthenticationResponse)this).Status == AuthenticationStatus.SetupRequired, OpenIdStrings.OperationOnlyValidForSetupRequiredState); diff --git a/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/OpenIdRelyingParty.cs b/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/OpenIdRelyingParty.cs index b190ce3477..db23cdb4cf 100644 --- a/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/OpenIdRelyingParty.cs +++ b/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/OpenIdRelyingParty.cs @@ -415,7 +415,7 @@ public OpenIdRelyingParty(IOpenIdApplicationStore applicationStore) /// Any individual generated request can satisfy the authentication. /// The generated requests are sorted in preferred order. /// Each request is generated as it is enumerated to. Associations are created only as - /// is called. + /// is called. /// No exception is thrown if no OpenID endpoints were discovered. /// An empty enumerable is returned instead. /// @@ -446,7 +446,7 @@ public OpenIdRelyingParty(IOpenIdApplicationStore applicationStore) /// Any individual generated request can satisfy the authentication. /// The generated requests are sorted in preferred order. /// Each request is generated as it is enumerated to. Associations are created only as - /// is called. + /// is called. /// No exception is thrown if no OpenID endpoints were discovered. /// An empty enumerable is returned instead. /// Requires an HttpContext.Current context. diff --git a/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/PositiveAuthenticationResponse.cs b/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/PositiveAuthenticationResponse.cs index f05abaa45e..d73d45f16c 100644 --- a/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/PositiveAuthenticationResponse.cs +++ b/src/DotNetOpenAuth.OpenId.RelyingParty/OpenId/RelyingParty/PositiveAuthenticationResponse.cs @@ -135,12 +135,14 @@ private PositiveAuthenticationResponse(PositiveAssertionResponse response, OpenI /// discovery on the Claimed Identifier. /// /// The relying party. - /// - /// Thrown when the Provider is asserting that a user controls an Identifier + /// The cancellation token. + /// + /// A task that completes with the asynchronous operation. + /// + /// Thrown when the Provider is asserting that a user controls an Identifier /// when discovery on that Identifier contradicts what the Provider says. /// This would be an indication of either a misconfigured Provider or - /// an attempt by someone to spoof another user's identity with a rogue Provider. - /// + /// an attempt by someone to spoof another user's identity with a rogue Provider. private async Task VerifyDiscoveryMatchesAssertionAsync(OpenIdRelyingParty relyingParty, CancellationToken cancellationToken) { Logger.OpenId.Debug("Verifying assertion matches identifier discovery results..."); diff --git a/src/DotNetOpenAuth.OpenId/OpenId/ChannelElements/OpenIdChannel.cs b/src/DotNetOpenAuth.OpenId/OpenId/ChannelElements/OpenIdChannel.cs index 0c93478f73..3b650fcde6 100644 --- a/src/DotNetOpenAuth.OpenId/OpenId/ChannelElements/OpenIdChannel.cs +++ b/src/DotNetOpenAuth.OpenId/OpenId/ChannelElements/OpenIdChannel.cs @@ -83,6 +83,9 @@ protected OpenIdChannel(IMessageFactory messageTypeProvider, IChannelBindingElem /// /// The message just received. /// The cancellation token. + /// + /// A task that completes with the asynchronous operation. + /// /// Thrown when the message is somehow invalid, except for check_authentication messages. /// This can be due to tampering, replay attack or expiration, among other things. protected override async Task ProcessIncomingMessageAsync(IProtocolMessage message, CancellationToken cancellationToken) { diff --git a/src/DotNetOpenAuth.OpenId/OpenId/Messages/NegativeAssertionResponse.cs b/src/DotNetOpenAuth.OpenId/OpenId/Messages/NegativeAssertionResponse.cs index ccb6a275f3..469c7cafb9 100644 --- a/src/DotNetOpenAuth.OpenId/OpenId/Messages/NegativeAssertionResponse.cs +++ b/src/DotNetOpenAuth.OpenId/OpenId/Messages/NegativeAssertionResponse.cs @@ -99,6 +99,7 @@ internal NegativeAssertionResponse(Version version, Uri relyingPartyReturnTo, st /// The request that the relying party sent. /// The cancellation token. /// The channel to use to simulate construction of the user_setup_url, if applicable. May be null, but the user_setup_url will not be constructed. + /// The negative assertion message that will indicate failure for the user to authenticate or an unwillingness to log into the relying party. internal static async Task CreateAsync(SignedResponseRequest request, CancellationToken cancellationToken, Channel channel = null) { var result = new NegativeAssertionResponse(request); diff --git a/src/DotNetOpenAuth.OpenId/OpenId/RelyingParty/IAuthenticationRequest.cs b/src/DotNetOpenAuth.OpenId/OpenId/RelyingParty/IAuthenticationRequest.cs index 34a25959c0..10b073014c 100644 --- a/src/DotNetOpenAuth.OpenId/OpenId/RelyingParty/IAuthenticationRequest.cs +++ b/src/DotNetOpenAuth.OpenId/OpenId/RelyingParty/IAuthenticationRequest.cs @@ -170,9 +170,11 @@ public interface IAuthenticationRequest { void AddExtension(IOpenIdMessageExtension extension); /// - /// Gets the HTTP response the relying party should send to the user agent + /// Gets the HTTP response the relying party should send to the user agent /// to redirect it to the OpenID Provider to start the OpenID authentication process. /// + /// The cancellation token. + /// The response message that will cause the client to redirect to the Provider. Task GetRedirectingResponseAsync(CancellationToken cancellationToken); } } diff --git a/src/DotNetOpenAuth.OpenId/OpenId/UriDiscoveryService.cs b/src/DotNetOpenAuth.OpenId/OpenId/UriDiscoveryService.cs index c5b7bb6ec4..7cb2a9ac70 100644 --- a/src/DotNetOpenAuth.OpenId/OpenId/UriDiscoveryService.cs +++ b/src/DotNetOpenAuth.OpenId/OpenId/UriDiscoveryService.cs @@ -32,6 +32,12 @@ public class UriDiscoveryService : IIdentifierDiscoveryService, IRequireHostFact public UriDiscoveryService() { } + /// + /// Gets or sets the host factories used by this instance. + /// + /// + /// The host factories. + /// public IHostFactories HostFactories { get; set; } #region IIdentifierDiscoveryService Members @@ -40,8 +46,7 @@ public class UriDiscoveryService : IIdentifierDiscoveryService, IRequireHostFact /// Performs discovery on the specified identifier. /// /// The identifier to perform discovery on. - /// The means to place outgoing HTTP requests. - /// if set to true, no further discovery services will be called for this identifier. + /// The cancellation token. /// /// A sequence of service endpoints yielded by discovery. Must not be null, but may be empty. /// diff --git a/src/DotNetOpenAuth.OpenId/OpenId/XriDiscoveryProxyService.cs b/src/DotNetOpenAuth.OpenId/OpenId/XriDiscoveryProxyService.cs index e13b027a63..a04f568804 100644 --- a/src/DotNetOpenAuth.OpenId/OpenId/XriDiscoveryProxyService.cs +++ b/src/DotNetOpenAuth.OpenId/OpenId/XriDiscoveryProxyService.cs @@ -78,8 +78,11 @@ public class XriDiscoveryProxyService : IIdentifierDiscoveryService, IRequireHos /// Downloads the XRDS document for this XRI. /// /// The identifier. - /// The request handler. - /// The XRDS document. + /// The host factories. + /// The cancellation token. + /// + /// The XRDS document. + /// private static async Task DownloadXrdsAsync(XriIdentifier identifier, IHostFactories hostFactories, CancellationToken cancellationToken) { Requires.NotNull(identifier, "identifier"); Requires.NotNull(hostFactories, "hostFactories"); diff --git a/src/DotNetOpenAuth.OpenId/Yadis/DiscoveryResult.cs b/src/DotNetOpenAuth.OpenId/Yadis/DiscoveryResult.cs index c993acd8f0..c56a170002 100644 --- a/src/DotNetOpenAuth.OpenId/Yadis/DiscoveryResult.cs +++ b/src/DotNetOpenAuth.OpenId/Yadis/DiscoveryResult.cs @@ -94,6 +94,9 @@ internal class DiscoveryResult { /// /// Reverts to the HTML response after the XRDS response didn't work out. /// + /// + /// A task that completes with the asynchronous operation. + /// internal async Task TryRevertToHtmlResponseAsync() { if (this.htmlFallback != null) { await this.ApplyHtmlResponseAsync(this.htmlFallback); @@ -105,6 +108,9 @@ internal class DiscoveryResult { /// Applies the HTML response to the object. /// /// The initial response. + /// + /// A task that completes with the asynchronous operation. + /// private async Task ApplyHtmlResponseAsync(HttpResponseMessage response) { Requires.NotNull(response, "response");