Rename IdTokenValidated to AuthenticationValidated.

Author: Tratcher

src/Microsoft.AspNet.Authentication.OpenIdConnect/Events/IdTokenValidatedContext.cs renamed to src/Microsoft.AspNet.Authentication.OpenIdConnect/Events/AuthenticationValidatedContext.cs

@@ -6,9 +6,9 @@
 
 namespace Microsoft.AspNet.Authentication.OpenIdConnect
 {
-    public class IdTokenValidatedContext : BaseControlContext<OpenIdConnectOptions>
+    public class AuthenticationValidatedContext : BaseControlContext<OpenIdConnectOptions>
     {
-        public IdTokenValidatedContext(HttpContext context, OpenIdConnectOptions options)
+        public AuthenticationValidatedContext(HttpContext context, OpenIdConnectOptions options)
             : base(context, options)
         {
         }

src/Microsoft.AspNet.Authentication.OpenIdConnect/Events/IOpenIdConnectEvents.cs

@@ -20,6 +20,11 @@ public interface IOpenIdConnectEvents
         /// </summary>
         Task AuthenticationFailed(AuthenticationFailedContext context);
 
+        /// <summary>
+        /// Invoked after the id token has passed validation and a ClaimsIdentity has been generated.
+        /// </summary>
+        Task AuthenticationValidated(AuthenticationValidatedContext context);
+
         /// <summary>
         /// Invoked after security token validation if an authorization code is present in the protocol message.
         /// </summary>
@@ -30,11 +35,6 @@ public interface IOpenIdConnectEvents
         /// </summary>
         Task AuthorizationResponseReceived(AuthorizationResponseReceivedContext context);
 
-        /// <summary>
-        /// Invoked after the id token has passed validation and a ClaimsIdentity has been generated.
-        /// </summary>
-        Task IdTokenValidated(IdTokenValidatedContext context);
-
         /// <summary>
         /// Invoked when a protocol message is first received.
         /// </summary>

src/Microsoft.AspNet.Authentication.OpenIdConnect/Events/OpenIdConnectEvents.cs

@@ -21,6 +21,11 @@ public class OpenIdConnectEvents : IOpenIdConnectEvents
         /// </summary>
         public Func<AuthenticationFailedContext, Task> OnAuthenticationFailed { get; set; } = context => Task.FromResult(0);
 
+        /// <summary>
+        /// Invoked after the id token has passed validation and a ClaimsIdentity has been generated.
+        /// </summary>
+        public Func<AuthenticationValidatedContext, Task> OnAuthenticationValidated { get; set; } = context => Task.FromResult(0);
+
         /// <summary>
         /// Invoked after security token validation if an authorization code is present in the protocol message.
         /// </summary>
@@ -31,11 +36,6 @@ public class OpenIdConnectEvents : IOpenIdConnectEvents
         /// </summary>
         public Func<AuthorizationResponseReceivedContext, Task> OnAuthorizationResponseReceived { get; set; } = context => Task.FromResult(0);
 
-        /// <summary>
-        /// Invoked after the id token has passed validation and a ClaimsIdentity has been generated.
-        /// </summary>
-        public Func<IdTokenValidatedContext, Task> OnIdTokenValidated { get; set; } = context => Task.FromResult(0);
-
         /// <summary>
         /// Invoked when a protocol message is first received.
         /// </summary>
@@ -65,12 +65,12 @@ public class OpenIdConnectEvents : IOpenIdConnectEvents
 
         public virtual Task AuthenticationFailed(AuthenticationFailedContext context) => OnAuthenticationFailed(context);
 
+        public virtual Task AuthenticationValidated(AuthenticationValidatedContext context) => OnAuthenticationValidated(context);
+
         public virtual Task AuthorizationCodeReceived(AuthorizationCodeReceivedContext context) => OnAuthorizationCodeReceived(context);
 
         public virtual Task AuthorizationResponseReceived(AuthorizationResponseReceivedContext context) => OnAuthorizationResponseReceived(context);
 
-        public virtual Task IdTokenValidated(IdTokenValidatedContext context) => OnIdTokenValidated(context);
-
         public virtual Task MessageReceived(MessageReceivedContext context) => OnMessageReceived(context);
 
         public virtual Task RedirectToAuthenticationEndpoint(RedirectContext context) => OnRedirectToAuthenticationEndpoint(context);

src/Microsoft.AspNet.Authentication.OpenIdConnect/OpenIdConnectHandler.cs

@@ -493,16 +493,16 @@ private async Task<AuthenticationTicket> HandleCodeOnlyFlow(OpenIdConnectMessage
 
             await ValidateOpenIdConnectProtocolAsync(null, message);
 
-            var securityTokenValidatedContext = await RunIdTokenValidatedEventAsync(message, ticket, tokenEndpointResponse);
-            if (securityTokenValidatedContext.HandledResponse)
+            var authenticationValidatedContext = await RunAuthenticationValidatedEventAsync(message, ticket, tokenEndpointResponse);
+            if (authenticationValidatedContext.HandledResponse)
             {
-                return securityTokenValidatedContext.AuthenticationTicket;
+                return authenticationValidatedContext.AuthenticationTicket;
             }
-            else if (securityTokenValidatedContext.Skipped)
+            else if (authenticationValidatedContext.Skipped)
             {
                 return null;
             }
-            ticket = securityTokenValidatedContext.AuthenticationTicket;
+            ticket = authenticationValidatedContext.AuthenticationTicket;
 
             if (Options.GetClaimsFromUserInfoEndpoint)
             {
@@ -524,17 +524,17 @@ private async Task<AuthenticationTicket> HandleIdTokenFlows(OpenIdConnectMessage
 
             await ValidateOpenIdConnectProtocolAsync(jwt, message);
 
-            var idTokenValidatedContext = await RunIdTokenValidatedEventAsync(message, ticket, tokenEndpointResponse: null);
-            if (idTokenValidatedContext.HandledResponse)
+            var authenticationValidatedContext = await RunAuthenticationValidatedEventAsync(message, ticket, tokenEndpointResponse: null);
+            if (authenticationValidatedContext.HandledResponse)
             {
-                return idTokenValidatedContext.AuthenticationTicket;
+                return authenticationValidatedContext.AuthenticationTicket;
             }
-            else if (idTokenValidatedContext.Skipped)
+            else if (authenticationValidatedContext.Skipped)
             {
                 return null;
             }
-            message = idTokenValidatedContext.ProtocolMessage;
-            ticket = idTokenValidatedContext.AuthenticationTicket;
+            message = authenticationValidatedContext.ProtocolMessage;
+            ticket = authenticationValidatedContext.AuthenticationTicket;
 
             // Hybrid Flow
             if (message.Code != null)
@@ -889,26 +889,26 @@ private async Task<TokenResponseReceivedContext> RunTokenResponseReceivedEventAs
             return tokenResponseReceivedContext;
         }
 
-        private async Task<IdTokenValidatedContext> RunIdTokenValidatedEventAsync(OpenIdConnectMessage message, AuthenticationTicket ticket, OpenIdConnectTokenEndpointResponse tokenEndpointResponse)
+        private async Task<AuthenticationValidatedContext> RunAuthenticationValidatedEventAsync(OpenIdConnectMessage message, AuthenticationTicket ticket, OpenIdConnectTokenEndpointResponse tokenEndpointResponse)
         {
-            var idTokenValidatedContext = new IdTokenValidatedContext(Context, Options)
+            var authenticationValidatedContext = new AuthenticationValidatedContext(Context, Options)
             {
                 AuthenticationTicket = ticket,
                 ProtocolMessage = message,
                 TokenEndpointResponse = tokenEndpointResponse,
             };
 
-            await Options.Events.IdTokenValidated(idTokenValidatedContext);
-            if (idTokenValidatedContext.HandledResponse)
+            await Options.Events.AuthenticationValidated(authenticationValidatedContext);
+            if (authenticationValidatedContext.HandledResponse)
             {
-                Logger.LogVerbose("The IdTokenValidated event returned Handled.");
+                Logger.LogVerbose("AuthenticationValidated.HandledResponse");
             }
-            else if (idTokenValidatedContext.Skipped)
+            else if (authenticationValidatedContext.Skipped)
             {
-                Logger.LogVerbose("The IdTokenValidated event returned Skipped.");
+                Logger.LogVerbose("AuthenticationValidated.Skipped");
             }
 
-            return idTokenValidatedContext;
+            return authenticationValidatedContext;
         }
 
         private async Task<UserInformationReceivedContext> RunUserInformationReceivedEventAsync(AuthenticationTicket ticket, OpenIdConnectMessage message, JObject user)