Fix aspnet#2330 - Reimagine *FormatterContext

This change simplifies InputFormatterContext/OutputFormatterContext by
swapping ActionContext for HttpContext.

This change is important especially for InputFormatterContext as it
decouples ModelState from ActionContext - allowing us to fix a
related bug where the _wrong_ ModelState can be passed in for a
TryUpdateModel operation.

Author: rynowak

src/Microsoft.AspNet.Mvc.Abstractions/InputFormatterContext.cs

@@ -2,33 +2,51 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using Microsoft.AspNet.Http;
+using Microsoft.AspNet.Mvc.ModelBinding;
 using Microsoft.Framework.Internal;
 
 namespace Microsoft.AspNet.Mvc
 {
     /// <summary>
-    /// Represents information used by an input formatter for
-    /// deserializing the request body into an object.
+    /// A context object used by an input formatter for deserializing the request body into an object.
     /// </summary>
     public class InputFormatterContext
     {
         /// <summary>
         /// Creates a new instance of <see cref="InputFormatterContext"/>.
         /// </summary>
-        public InputFormatterContext([NotNull] ActionContext actionContext,
-                                     [NotNull] Type modelType)
+        /// <param name="httpContext">
+        /// The <see cref="Http.HttpContext"/> for the current operation.
+        /// </param>
+        /// <param name="modelState">
+        /// The <see cref="ModelStateDictionary"/> for recording errors.
+        /// </param>
+        /// <param name="modelType">
+        /// The <see cref="Type"/> of the model to deserialize.
+        /// </param>
+        public InputFormatterContext(
+            [NotNull] HttpContext httpContext,
+            [NotNull] ModelStateDictionary modelState,
+            [NotNull] Type modelType)
         {
-            ActionContext = actionContext;
+            HttpContext = httpContext;
+            ModelState = modelState;
             ModelType = modelType;
         }
 
         /// <summary>
-        /// Action context associated with the current call.
+        /// Gets the <see cref="Http.HttpContext"/> associated with the current operation.
         /// </summary>
-        public ActionContext ActionContext { get; private set; }
+        public HttpContext HttpContext { get; private set; }
 
         /// <summary>
-        /// Represents the expected type of the model represented by the request body.
+        /// Gets the <see cref="ModelStateDictionary"/> associated with the current operation.
+        /// </summary>
+        public ModelStateDictionary ModelState { get; }
+
+        /// <summary>
+        /// Gets the expected <see cref="Type"/> of the model represented by the request body.
         /// </summary>
         public Type ModelType { get; private set; }
     }

src/Microsoft.AspNet.Mvc.Abstractions/OutputFormatterContext.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Text;
+using Microsoft.AspNet.Http;
 using Microsoft.Net.Http.Headers;
 
 namespace Microsoft.AspNet.Mvc
@@ -24,9 +25,9 @@ public class OutputFormatterContext
         public Type DeclaredType { get; set; }
 
         /// <summary>
-        /// Action context associated with the current call.
+        /// Gets or sets the <see cref="HttpContext"/> context associated with the current operation.
         /// </summary>
-        public ActionContext ActionContext { get; set; }
+        public HttpContext HttpContext { get; set; }
 
         /// <summary>
         /// The encoding which is chosen by the selected formatter.

src/Microsoft.AspNet.Mvc.Core/ActionResults/JsonResult.cs

@@ -101,7 +101,7 @@ public override async Task ExecuteResultAsync([NotNull] ActionContext context)
 
             var formatterContext = new OutputFormatterContext()
             {
-                ActionContext = context,
+                HttpContext = context.HttpContext,
                 DeclaredType = objectResult.DeclaredType,
                 Object = Value,
             };
@@ -125,7 +125,6 @@ private IOutputFormatter SelectFormatter(ObjectResult objectResult, OutputFormat
             {
                 // If no formatter was provided, then run Conneg with the formatters configured in options.
                 var formatters = formatterContext
-                    .ActionContext
                     .HttpContext
                     .RequestServices
                     .GetRequiredService<IOptions<MvcOptions>>()
@@ -140,7 +139,6 @@ private IOutputFormatter SelectFormatter(ObjectResult objectResult, OutputFormat
                     // If the available user-configured formatters can't write this type, then fall back to the
                     // 'global' one.
                     formatter = formatterContext
-                        .ActionContext
                         .HttpContext
                         .RequestServices
                         .GetRequiredService<JsonOutputFormatter>();

src/Microsoft.AspNet.Mvc.Core/ActionResults/ObjectResult.cs

@@ -49,7 +49,7 @@ public override async Task ExecuteResultAsync(ActionContext context)
             var formatterContext = new OutputFormatterContext()
             {
                 DeclaredType = DeclaredType,
-                ActionContext = context,
+                HttpContext = context.HttpContext,
                 Object = Value,
                 StatusCode = StatusCode
             };
@@ -83,8 +83,7 @@ public virtual IOutputFormatter SelectFormatter(
             OutputFormatterContext formatterContext,
             IEnumerable<IOutputFormatter> formatters)
         {
-            var logger = formatterContext.ActionContext.HttpContext.RequestServices
-                .GetRequiredService<ILogger<ObjectResult>>();
+            var logger = formatterContext.HttpContext.RequestServices.GetRequiredService<ILogger<ObjectResult>>();
 
             // Check if any content-type was explicitly set (for example, via ProducesAttribute 
             // or Url path extension mapping). If yes, then ignore content-negotiation and use this content-type.
@@ -108,7 +107,7 @@ public virtual IOutputFormatter SelectFormatter(
                 // which can write the type.
                 MediaTypeHeaderValue requestContentType = null;
                 MediaTypeHeaderValue.TryParse(
-                    formatterContext.ActionContext.HttpContext.Request.ContentType,
+                    formatterContext.HttpContext.Request.ContentType,
                     out requestContentType);
                 if (!sortedAcceptHeaderMediaTypes.Any() && requestContentType == null)
                 {
@@ -240,17 +239,18 @@ public virtual IOutputFormatter SelectFormatterUsingAnyAcceptableContentType(
         private IEnumerable<MediaTypeHeaderValue> GetSortedAcceptHeaderMediaTypes(
             OutputFormatterContext formatterContext)
         {
-            var request = formatterContext.ActionContext.HttpContext.Request;
+            var request = formatterContext.HttpContext.Request;
             var incomingAcceptHeaderMediaTypes = request.GetTypedHeaders().Accept ?? new MediaTypeHeaderValue[] { };
 
             // By default we want to ignore considering accept headers for content negotiation when
             // they have a media type like */* in them. Browsers typically have these media types.
             // In these cases we would want the first formatter in the list of output formatters to
             // write the response. This default behavior can be changed through options, so checking here.
-            var options = formatterContext.ActionContext.HttpContext
-                                                        .RequestServices
-                                                        .GetRequiredService<IOptions<MvcOptions>>()
-                                                        .Options;
+            var options = formatterContext
+                .HttpContext
+                .RequestServices
+                .GetRequiredService<IOptions<MvcOptions>>()
+                .Options;
 
             var respectAcceptHeader = true;
             if (options.RespectBrowserAcceptHeader == false

src/Microsoft.AspNet.Mvc.Core/Formatters/HttpNoContentOutputFormatter.cs

@@ -33,7 +33,7 @@ public bool CanWriteResult(OutputFormatterContext context, MediaTypeHeaderValue
 
         public Task WriteAsync(OutputFormatterContext context)
         {
-            var response = context.ActionContext.HttpContext.Response;
+            var response = context.HttpContext.Response;
             response.ContentLength = 0;
             response.StatusCode = context.StatusCode ?? StatusCodes.Status204NoContent;
             return Task.FromResult(true);

src/Microsoft.AspNet.Mvc.Core/Formatters/HttpNotAcceptableOutputFormatter.cs

@@ -21,7 +21,7 @@ public bool CanWriteResult(OutputFormatterContext context, MediaTypeHeaderValue
         /// <inheritdoc />
         public Task WriteAsync(OutputFormatterContext context)
         {
-            var response = context.ActionContext.HttpContext.Response;
+            var response = context.HttpContext.Response;
             response.StatusCode = StatusCodes.Status406NotAcceptable;
             return Task.FromResult(true);
         }

src/Microsoft.AspNet.Mvc.Core/Formatters/InputFormatter.cs

@@ -48,7 +48,7 @@ public virtual bool CanRead(InputFormatterContext context)
                 return false;
             }
 
-            var contentType = context.ActionContext.HttpContext.Request.ContentType;
+            var contentType = context.HttpContext.Request.ContentType;
             MediaTypeHeaderValue requestContentType;
             if (!MediaTypeHeaderValue.TryParse(contentType, out requestContentType))
             {
@@ -72,7 +72,7 @@ protected virtual bool CanReadType(Type type)
         /// <inheritdoc />
         public virtual async Task<object> ReadAsync(InputFormatterContext context)
         {
-            var request = context.ActionContext.HttpContext.Request;
+            var request = context.HttpContext.Request;
             if (request.ContentLength == 0)
             {
                 return GetDefaultValueForType(context.ModelType);

src/Microsoft.AspNet.Mvc.Core/Formatters/JsonInputFormatter.cs

@@ -52,7 +52,7 @@ public JsonSerializerSettings SerializerSettings
         public override Task<object> ReadRequestBodyAsync([NotNull] InputFormatterContext context)
         {
             var type = context.ModelType;
-            var request = context.ActionContext.HttpContext.Request;
+            var request = context.HttpContext.Request;
             MediaTypeHeaderValue requestContentType = null;
             MediaTypeHeaderValue.TryParse(request.ContentType, out requestContentType);
 
@@ -70,7 +70,7 @@ public override Task<object> ReadRequestBodyAsync([NotNull] InputFormatterContex
                 errorHandler = (sender, e) =>
                 {
                     var exception = e.ErrorContext.Error;
-                    context.ActionContext.ModelState.TryAddModelError(e.ErrorContext.Path, e.ErrorContext.Error);
+                    context.ModelState.TryAddModelError(e.ErrorContext.Path, e.ErrorContext.Error);
 
                     // Error must always be marked as handled
                     // Failure to do so can cause the exception to be rethrown at every recursive level and

src/Microsoft.AspNet.Mvc.Core/Formatters/JsonOutputFormatter.cs

@@ -72,7 +72,7 @@ private JsonSerializer CreateJsonSerializer()
 
         public override Task WriteResponseBodyAsync(OutputFormatterContext context)
         {
-            var response = context.ActionContext.HttpContext.Response;
+            var response = context.HttpContext.Response;
             var selectedEncoding = context.SelectedEncoding;
 
             using (var writer = new HttpResponseStreamWriter(response.Body, selectedEncoding))

src/Microsoft.AspNet.Mvc.Core/Formatters/OutputFormatter.cs

@@ -104,7 +104,7 @@ public virtual IReadOnlyList<MediaTypeHeaderValue> GetSupportedContentTypes(
         /// <returns>The <see cref="Encoding"/> to use when reading the request or writing the response.</returns>
         public virtual Encoding SelectCharacterEncoding([NotNull] OutputFormatterContext context)
         {
-            var request = context.ActionContext.HttpContext.Request;
+            var request = context.HttpContext.Request;
             var encoding = MatchAcceptCharacterEncoding(request.GetTypedHeaders().AcceptCharset);
             if (encoding == null)
             {
@@ -195,7 +195,7 @@ public virtual void WriteResponseHeaders([NotNull] OutputFormatterContext contex
             selectedMediaType.Charset = selectedEncoding.WebName;
 
             context.SelectedContentType = context.SelectedContentType ?? selectedMediaType;
-            var response = context.ActionContext.HttpContext.Response;
+            var response = context.HttpContext.Response;
             response.ContentType = selectedMediaType.ToString();
         }