Addressed feedback and also added TimeoutCancellationToken feature and also added functional tests now.

Author: kichalla

src/Microsoft.AspNet.Mvc.Core/Filters/AsyncTimeoutAttribute.cs

@@ -9,8 +9,8 @@
 namespace Microsoft.AspNet.Mvc
 {
     /// <summary>
-    /// Represents an attribute that is used to set the timeout value, in milliseconds, 
-    /// which when elapsed will cause the current request to be aborted.
+    /// Used to set the timeout value, in milliseconds, which when elapsed will 
+    /// cause the current request to be aborted.
     /// </summary>
     [AttributeUsage(
         AttributeTargets.Class | AttributeTargets.Method,
@@ -21,49 +21,37 @@ public class AsyncTimeoutAttribute : Attribute, IAsyncResourceFilter
         /// <summary>
         /// Initializes a new instance of <see cref="AsyncTimeoutAttribute"/>.
         /// </summary>
-        /// <param name="duration">The duration in milliseconds.</param>
-        public AsyncTimeoutAttribute(int duration)
+        /// <param name="durationInMilliseconds">The duration in milliseconds.</param>
+        public AsyncTimeoutAttribute(int durationInMilliseconds)
         {
-            if (duration < -1)
+            if (durationInMilliseconds <= 0)
             {
-                throw new ArgumentException(
-                    Resources.FormatAsyncTimeoutAttribute_InvalidTimeout(duration, nameof(duration))); 
+                throw new ArgumentOutOfRangeException(
+                    nameof(durationInMilliseconds), 
+                    durationInMilliseconds, 
+                    Resources.AsyncTimeoutAttribute_InvalidTimeout);
             }
 
-            Duration = duration;
+            DurationInMilliseconds = durationInMilliseconds;
         }
 
         /// <summary>
         /// The timeout duration in milliseconds.
         /// </summary>
-        public int Duration { get; }
+        public int DurationInMilliseconds { get; }
 
         public async Task OnResourceExecutionAsync(
             [NotNull] ResourceExecutingContext context,
             [NotNull] ResourceExecutionDelegate next)
         {
-            var httpContext = context.HttpContext;
-
-            // Get a task that will complete after a time delay.
-            var timeDelayTask = Task.Delay(Duration, cancellationToken: httpContext.RequestAborted);
-
-            // Task representing later stages of the pipeline.
-            var pipelineTask = next();
-
-            // Get the first task which completed.
-            var completedTask = await Task.WhenAny(pipelineTask, timeDelayTask);
-
-            if (completedTask == pipelineTask)
-            {
-                // Task completed within timeout, but it could be in faulted or canceled state.
-                // Allow the following line to throw exception and be handled somewhere else.
-                await completedTask;
-            }
-            else
-            {
-                // Pipeline task did not complete within timeout, so abort the request.
-                httpContext.Abort();
-            }
+            // Set the feature which provides the cancellation token to later stages
+            // in the pipeline. This cancellation token gets invoked when the timeout value
+            // elapses. One can register to this cancellation token to get notified when the
+            // timeout occurs to take any action.
+            context.HttpContext.SetFeature<ITimeoutCancellationTokenFeature>(
+                new TimeoutCancellationTokenFeature(DurationInMilliseconds));
+
+            await next();
         }
     }
 }

src/Microsoft.AspNet.Mvc.Core/ITimeoutCancellationTokenFeature.cs

@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Threading;
+
+namespace Microsoft.AspNet.Mvc
+{
+    /// <summary>
+    /// Provides a <see cref="CancellationToken"/> which gets invoked after a specified timeout value.
+    /// </summary>
+    public interface ITimeoutCancellationTokenFeature
+    {
+        /// <summary>
+        /// Gets a <see cref="CancellationToken"/> which gets invoked 
+        /// after a specified timeout value.
+        /// </summary>
+        CancellationToken TimeoutCancellationToken { get; }
+    }
+}

src/Microsoft.AspNet.Mvc.Core/ModelBinders/CancellationTokenModelBinder.cs

@@ -0,0 +1,46 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.AspNet.Mvc.ModelBinding
+{
+    /// <summary>
+    /// Represents a model binder which can bind models of type <see cref="CancellationToken"/>.
+    /// </summary>
+    /// <remarks>
+    /// The <see cref="CancellationToken"/> provided by this binder is invoked after a supplied timeout value.
+    /// This binder depends on the <see cref="ITimeoutCancellationTokenFeature"/> to get the token. This feature
+    /// is typically set through the <see cref="AsyncTimeoutAttribute"/>.
+    /// </remarks>
+    public class TimeoutCancellationTokenModelBinder : IModelBinder
+    {
+        /// <inheritdoc />
+        public Task<ModelBindingResult> BindModelAsync(ModelBindingContext bindingContext)
+        {
+            if (bindingContext.ModelType == typeof(CancellationToken))
+            {
+                var httpContext = bindingContext.OperationBindingContext.HttpContext;
+
+                var timeoutTokenFeature = httpContext.GetFeature<ITimeoutCancellationTokenFeature>();
+                if (timeoutTokenFeature != null)
+                {
+                    return Task.FromResult(new ModelBindingResult(
+                        model: timeoutTokenFeature.TimeoutCancellationToken,
+                        key: bindingContext.ModelName, 
+                        isModelSet: true));
+                }
+                else
+                {
+                    return Task.FromResult(new ModelBindingResult(
+                        model: CancellationToken.None,
+                        key: bindingContext.ModelName,
+                        isModelSet: false));
+                }
+            }
+
+            return Task.FromResult<ModelBindingResult>(null);
+        }
+    }
+}

src/Microsoft.AspNet.Mvc.Core/Properties/Resources.Designer.cs

@@ -449,6 +449,6 @@
     <value>The model's runtime type '{0}' is not assignable to the type '{1}'.</value>
   </data>
   <data name="AsyncTimeoutAttribute_InvalidTimeout" xml:space="preserve">
-    <value>The value '{0}' for argument '{1}' is invalid. The timeout value must be non-negative.</value>
+    <value>The timeout value must be greater than 0.</value>
   </data>
 </root>

src/Microsoft.AspNet.Mvc.Core/Resources.resx

@@ -0,0 +1,36 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Threading;
+using Microsoft.AspNet.Mvc.Core;
+
+namespace Microsoft.AspNet.Mvc
+{
+    /// <inheritdoc />
+    public class TimeoutCancellationTokenFeature : ITimeoutCancellationTokenFeature
+    {
+        /// <summary>
+        /// Initializes a new instance of <see cref="TimeoutCancellationTokenFeature"/>.
+        /// </summary>
+        /// <param name="durationInMilliseconds">The duration in milliseconds.</param>
+        public TimeoutCancellationTokenFeature(int durationInMilliseconds)
+        {
+            if (durationInMilliseconds <= 0)
+            {
+                throw new ArgumentOutOfRangeException(
+                    nameof(durationInMilliseconds),
+                    durationInMilliseconds,
+                    Resources.AsyncTimeoutAttribute_InvalidTimeout);
+            }
+
+            var timeoutCancellationTokenSource = new CancellationTokenSource();
+            timeoutCancellationTokenSource.CancelAfter(millisecondsDelay: durationInMilliseconds);
+
+            TimeoutCancellationToken = timeoutCancellationTokenSource.Token;
+        }
+
+        /// <inheritdoc />
+        public CancellationToken TimeoutCancellationToken { get; }
+    }
+}

src/Microsoft.AspNet.Mvc.Core/TimeoutCancellationTokenFeature.cs

@@ -34,7 +34,7 @@ public static void ConfigureMvcOptions(MvcOptions options)
             options.ModelBinders.Add(new HeaderModelBinder());
             options.ModelBinders.Add(new TypeConverterModelBinder());
             options.ModelBinders.Add(new TypeMatchModelBinder());
-            options.ModelBinders.Add(new CancellationTokenModelBinder());
+            options.ModelBinders.Add(new TimeoutCancellationTokenModelBinder());
             options.ModelBinders.Add(new ByteArrayModelBinder());
             options.ModelBinders.Add(new FormFileModelBinder());
             options.ModelBinders.Add(new FormCollectionModelBinder());

src/Microsoft.AspNet.Mvc/MvcOptionsSetup.cs

@@ -4,6 +4,7 @@
 #if ASPNET50
 using System.Threading.Tasks;
 using Microsoft.AspNet.Http;
+using Microsoft.AspNet.Http.Core;
 using Microsoft.AspNet.Routing;
 using Moq;
 using Xunit;
@@ -13,47 +14,22 @@ namespace Microsoft.AspNet.Mvc.Test
     public class AsyncTimeoutAttributeTest
     {
         [Fact]
-        public async Task RequestIsAborted_AfterTimeoutDurationElapses()
+        public async Task SetsTimeoutCancellationTokenFeature_OnExecution()
         {
             // Arrange
-            var httpContext = new Mock<HttpContext>();
+            var httpContext = new DefaultHttpContext();
             var asyncTimeoutAttribute = new AsyncTimeoutAttribute(1 * 1000); // 1 second
-            var resourceExecutingContext = GetResourceExecutingContext(httpContext.Object);
-            
-            // Act
-            await asyncTimeoutAttribute.OnResourceExecutionAsync(
-                resourceExecutingContext, 
-                async () =>
-                {
-                    // Imagine here the rest of pipeline(ex: model-binding->action filters-action) being executed
-                    await Task.Delay(10 * 1000); // 10 seconds
-                    return null;
-                });
-
-            // Assert
-            httpContext.Verify(hc => hc.Abort(), Times.Once);
-        }
+            var resourceExecutingContext = GetResourceExecutingContext(httpContext);
 
-        [Fact]
-        public async Task RequestIsNotAborted_BeforeTimeoutDurationElapses()
-        {
-            // Arrange
-            var httpContext = new Mock<HttpContext>();
-            var asyncTimeoutAttribute = new AsyncTimeoutAttribute(10 * 1000); // 10 seconds
-            var resourceExecutingContext = GetResourceExecutingContext(httpContext.Object);
-            
             // Act
             await asyncTimeoutAttribute.OnResourceExecutionAsync(
                 resourceExecutingContext,
-                async () =>
-                {
-                    // Imagine here the rest of pipeline(ex: model-binding->action filters-action) being executed
-                    await Task.Delay(1 * 1000); // 1 second
-                    return null;
-                });
+                () => Task.FromResult<ResourceExecutedContext>(null));
 
             // Assert
-            httpContext.Verify(hc => hc.Abort(), Times.Never);
+            var timeoutFeature = resourceExecutingContext.HttpContext.GetFeature<ITimeoutCancellationTokenFeature>();
+            Assert.NotNull(timeoutFeature);
+            Assert.NotNull(timeoutFeature.TimeoutCancellationToken);
         }
 
         private ResourceExecutingContext GetResourceExecutingContext(HttpContext httpContext)

test/Microsoft.AspNet.Mvc.Core.Test/Filters/AsyncTimeoutAttributeTest.cs

@@ -0,0 +1,84 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Threading.Tasks;
+using BasicWebSite;
+using Microsoft.AspNet.Builder;
+using Microsoft.AspNet.TestHost;
+using Newtonsoft.Json;
+using Xunit;
+
+namespace Microsoft.AspNet.Mvc.FunctionalTests
+{
+    public class AsyncTimeoutAttributeTest
+    {
+        private readonly IServiceProvider _provider = TestHelper.CreateServices(nameof(BasicWebSite));
+        private readonly Action<IApplicationBuilder> _app = new Startup().Configure;
+
+        [Theory]
+        [InlineData("http://localhost/AsyncTimeout/ActionWithTimeoutAttribute")]
+        [InlineData("http://localhost/AsyncTimeoutOnController/ActionWithTimeoutAttribute")]
+        public async Task AsyncTimeOutAttribute_IsDecorated_AndCancellationTokenIsBound(string url)
+        {
+            // Arrange
+            var server = TestServer.Create(_provider, _app);
+            var client = server.CreateClient();
+            var expected = "CancellationToken is present";
+
+            // Act
+            var response = await client.GetAsync(url);
+
+            // Assert
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            var data = await response.Content.ReadAsStringAsync();
+            Assert.Equal(expected, data);
+        }
+
+        [Fact]
+        public async Task AsyncTimeOutAttribute_IsNotDecorated_AndCancellationToken_IsNone()
+        {
+            // Arrange
+            var server = TestServer.Create(_provider, _app);
+            var client = server.CreateClient();
+            var expected = "CancellationToken is not present";
+
+            // Act
+            var response = await client.GetAsync("http://localhost/AsyncTimeout/ActionWithNoTimeoutAttribute");
+
+            // Assert
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            var data = await response.Content.ReadAsStringAsync();
+            Assert.Equal(expected, data);
+        }
+
+        [Theory]
+        [InlineData("http://localhost/AsyncTimeout")]
+        [InlineData("http://localhost/AsyncTimeoutOnController")]
+        public async Task TimeoutIsTriggered(string baseUrl)
+        {
+            // Arrange
+            var expected = "Hello World!";
+            var expectedCorrelationId = Guid.NewGuid().ToString();
+            var server = TestServer.Create(_provider, _app);
+            var client = server.CreateClient();
+            client.DefaultRequestHeaders.Add("CorrelationId", expectedCorrelationId);
+
+            // Act
+            var response = await client.GetAsync(string.Format("{0}/LongRunningAction", baseUrl));
+
+            // Assert
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            var data = await response.Content.ReadAsStringAsync();
+            Assert.Equal(expected, data);
+
+            response = await client.GetAsync(string.Format("{0}/TimeoutTriggerLogs", baseUrl));
+            data = await response.Content.ReadAsStringAsync();
+            var timeoutTriggerLogs = JsonConvert.DeserializeObject<List<string>>(data);
+            Assert.NotNull(timeoutTriggerLogs);
+            Assert.Contains(expectedCorrelationId, timeoutTriggerLogs);
+        }
+    }
+}