more feedback

BrennanConroy · BrennanConroy · commit 24c9f8c015a6 · 2016-10-12T10:52:20.000-07:00
diff --git a/src/Microsoft.AspNetCore.ResponseCaching/Internal/HttpHeaderParsingHelpers.cs b/src/Microsoft.AspNetCore.ResponseCaching/Internal/HttpHeaderParsingHelpers.cs
@@ -7,7 +7,7 @@
 
 namespace Microsoft.AspNetCore.ResponseCaching.Internal
 {
-    internal static class ParsingHelpers
+    internal static class HttpHeaderParsingHelpers
     {
         private static readonly string[] DateFormats = new string[] {
             // "r", // RFC 1123, required output format but too strict for input
@@ -32,9 +32,11 @@ internal static class ParsingHelpers
 
         // Try the various date formats in the order listed above.
         // We should accept a wide verity of common formats, but only output RFC 1123 style dates.
-        internal static bool TryParseDate(string input, out DateTimeOffset result) => DateTimeOffset.TryParseExact(input, DateFormats, DateTimeFormatInfo.InvariantInfo,
+        internal static bool TryParseHeaderDate(string input, out DateTimeOffset result) => DateTimeOffset.TryParseExact(input, DateFormats, DateTimeFormatInfo.InvariantInfo,
                 DateTimeStyles.AllowWhiteSpaces | DateTimeStyles.AssumeUniversal, out result);
 
+        // Try to get the value of a specific header from a list of headers
+        // e.g. "header1=10, header2=30"
         internal static bool TryGetHeaderValue(StringValues headers, string headerName, out int value)
         {
             value = 0;
@@ -54,6 +56,20 @@ internal static bool TryGetHeaderValue(StringValues headers, string headerName,
             return false;
         }
 
+        internal static bool HeaderContains(StringValues headers, string headerName)
+        {
+            foreach (var header in headers)
+            {
+                var index = header.IndexOf(headerName, StringComparison.OrdinalIgnoreCase);
+                if (index != -1)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
         private static bool TryParseHeaderValue(int startIndex, string header, out int value)
         {
             var found = false;
diff --git a/src/Microsoft.AspNetCore.ResponseCaching/Internal/ResponseCacheContext.cs b/src/Microsoft.AspNetCore.ResponseCaching/Internal/ResponseCacheContext.cs
@@ -65,7 +65,7 @@ internal DateTimeOffset? ResponseDate
                 {
                     _parsedResponseDate = true;
                     DateTimeOffset date;
-                    if (ParsingHelpers.TryParseDate(HttpContext.Response.Headers[HeaderNames.Date], out date))
+                    if (HttpHeaderParsingHelpers.TryParseHeaderDate(HttpContext.Response.Headers[HeaderNames.Date], out date))
                     {
                         _responseDate = date;
                     }
@@ -92,7 +92,7 @@ internal DateTimeOffset? ResponseExpires
                 {
                     _parsedResponseExpires = true;
                     DateTimeOffset expires;
-                    if (ParsingHelpers.TryParseDate(HttpContext.Response.Headers[HeaderNames.Expires], out expires))
+                    if (HttpHeaderParsingHelpers.TryParseHeaderDate(HttpContext.Response.Headers[HeaderNames.Expires], out expires))
                     {
                         _responseExpires = expires;
                     }
@@ -114,7 +114,7 @@ internal TimeSpan? ResponseSharedMaxAge
                     _parsedResponseSharedMaxAge = true;
                     _responseSharedMaxAge = null;
                     int seconds;
-                    if (ParsingHelpers.TryGetHeaderValue(HttpContext.Response.Headers[HeaderNames.CacheControl], CacheControlValues.SharedMaxAgeString, out seconds))
+                    if (HttpHeaderParsingHelpers.TryGetHeaderValue(HttpContext.Response.Headers[HeaderNames.CacheControl], CacheControlValues.SharedMaxAgeString, out seconds))
                     {
                         _responseSharedMaxAge = TimeSpan.FromSeconds(seconds);
                     }
@@ -132,7 +132,7 @@ internal TimeSpan? ResponseMaxAge
                     _parsedResponseMaxAge = true;
                     _responseMaxAge = null;
                     int seconds;
-                    if (ParsingHelpers.TryGetHeaderValue(HttpContext.Response.Headers[HeaderNames.CacheControl], CacheControlValues.MaxAgeString, out seconds))
+                    if (HttpHeaderParsingHelpers.TryGetHeaderValue(HttpContext.Response.Headers[HeaderNames.CacheControl], CacheControlValues.MaxAgeString, out seconds))
                     {
                         _responseMaxAge = TimeSpan.FromSeconds(seconds);
                     }
diff --git a/src/Microsoft.AspNetCore.ResponseCaching/Internal/ResponseCachePolicyProvider.cs b/src/Microsoft.AspNetCore.ResponseCaching/Internal/ResponseCachePolicyProvider.cs
@@ -30,26 +30,20 @@ public virtual bool IsRequestCacheable(ResponseCacheContext context)
             // Verify request cache-control parameters
             if (!StringValues.IsNullOrEmpty(request.Headers[HeaderNames.CacheControl]))
             {
-                foreach (var header in request.Headers[HeaderNames.CacheControl])
+                if (HttpHeaderParsingHelpers.HeaderContains(request.Headers[HeaderNames.CacheControl], CacheControlValues.NoCacheString))
                 {
-                    if (header.IndexOf(CacheControlValues.NoCacheString, StringComparison.OrdinalIgnoreCase) != -1)
-                    {
-                        context.Logger.LogRequestWithNoCacheNotCacheable();
-                        return false;
-                    }
+                    context.Logger.LogRequestWithNoCacheNotCacheable();
+                    return false;
                 }
             }
             else
             {
                 // Support for legacy HTTP 1.0 cache directive
                 var pragmaHeaderValues = request.Headers[HeaderNames.Pragma];
-                foreach (var directive in pragmaHeaderValues)
+                if (HttpHeaderParsingHelpers.HeaderContains(request.Headers[HeaderNames.Pragma], CacheControlValues.NoCacheString))
                 {
-                    if (string.Equals(CacheControlValues.NoCacheString, directive, StringComparison.OrdinalIgnoreCase))
-                    {
-                        context.Logger.LogRequestWithPragmaNoCacheNotCacheable();
-                        return false;
-                    }
+                    context.Logger.LogRequestWithPragmaNoCacheNotCacheable();
+                    return false;
                 }
             }
 
@@ -61,48 +55,30 @@ public virtual bool IsResponseCacheable(ResponseCacheContext context)
             var responseCacheControlHeader = context.HttpContext.Response.Headers[HeaderNames.CacheControl];
 
             // Only cache pages explicitly marked with public
-            var isPublic = false;
-            foreach (var header in responseCacheControlHeader)
-            {
-                if (header.IndexOf(CacheControlValues.PublicString, StringComparison.OrdinalIgnoreCase) != -1)
-                {
-                    isPublic = true;
-                    break;
-                }
-            }
-            if (!isPublic)
+            if (!HttpHeaderParsingHelpers.HeaderContains(responseCacheControlHeader, CacheControlValues.PublicString))
             {
                 context.Logger.LogResponseWithoutPublicNotCacheable();
                 return false;
             }
 
             // Check no-store
-            foreach (var header in context.HttpContext.Request.Headers[HeaderNames.CacheControl])
+            if (HttpHeaderParsingHelpers.HeaderContains(context.HttpContext.Request.Headers[HeaderNames.CacheControl], CacheControlValues.NoStoreString))
             {
-                if (header.IndexOf(CacheControlValues.NoStoreString, StringComparison.OrdinalIgnoreCase) != -1)
-                {
-                    context.Logger.LogResponseWithNoStoreNotCacheable();
-                    return false;
-                }
+                context.Logger.LogResponseWithNoStoreNotCacheable();
+                return false;
             }
 
-            foreach (var header in responseCacheControlHeader)
+            if (HttpHeaderParsingHelpers.HeaderContains(responseCacheControlHeader, CacheControlValues.NoStoreString))
             {
-                if (header.IndexOf(CacheControlValues.NoStoreString, StringComparison.OrdinalIgnoreCase) != -1)
-                {
-                    context.Logger.LogResponseWithNoStoreNotCacheable();
-                    return false;
-                }
+                context.Logger.LogResponseWithNoStoreNotCacheable();
+                return false;
             }
 
             // Check no-cache
-            foreach (var header in responseCacheControlHeader)
+            if (HttpHeaderParsingHelpers.HeaderContains(responseCacheControlHeader, CacheControlValues.NoCacheString))
             {
-                if (header.IndexOf(CacheControlValues.NoCacheString, StringComparison.OrdinalIgnoreCase) != -1)
-                {
-                    context.Logger.LogResponseWithNoCacheNotCacheable();
-                    return false;
-                }
+                context.Logger.LogResponseWithNoCacheNotCacheable();
+                return false;
             }
 
             var response = context.HttpContext.Response;
@@ -123,13 +99,10 @@ public virtual bool IsResponseCacheable(ResponseCacheContext context)
             }
 
             // Check private
-            foreach (var header in responseCacheControlHeader)
+            if (HttpHeaderParsingHelpers.HeaderContains(responseCacheControlHeader, CacheControlValues.PrivateString))
             {
-                if (header.IndexOf(CacheControlValues.PrivateString, StringComparison.OrdinalIgnoreCase) != -1)
-                {
-                    context.Logger.LogResponseWithPrivateNotCacheable();
-                    return false;
-                }
+                context.Logger.LogResponseWithPrivateNotCacheable();
+                return false;
             }
 
             // Check response code
@@ -191,7 +164,7 @@ public virtual bool IsCachedEntryFresh(ResponseCacheContext context)
 
             // Add min-fresh requirements
             int seconds;
-            if (ParsingHelpers.TryGetHeaderValue(requestCacheControlHeaders, CacheControlValues.MinFreshString, out seconds))
+            if (HttpHeaderParsingHelpers.TryGetHeaderValue(requestCacheControlHeaders, CacheControlValues.MinFreshString, out seconds))
             {
                 var minFresh = TimeSpan.FromSeconds(seconds);
                 age += minFresh;
@@ -200,7 +173,7 @@ public virtual bool IsCachedEntryFresh(ResponseCacheContext context)
 
             // Validate shared max age, this overrides any max age settings for shared caches
             TimeSpan? cachedSharedMaxAge = null;
-            if (ParsingHelpers.TryGetHeaderValue(cachedControlHeaders, CacheControlValues.SharedMaxAgeString, out seconds))
+            if (HttpHeaderParsingHelpers.TryGetHeaderValue(cachedControlHeaders, CacheControlValues.SharedMaxAgeString, out seconds))
             {
                 cachedSharedMaxAge = TimeSpan.FromSeconds(seconds);
             }
@@ -214,13 +187,13 @@ public virtual bool IsCachedEntryFresh(ResponseCacheContext context)
             else if (!cachedSharedMaxAge.HasValue)
             {
                 TimeSpan? requestMaxAge = null;
-                if (ParsingHelpers.TryGetHeaderValue(requestCacheControlHeaders, CacheControlValues.MaxAgeString, out seconds))
+                if (HttpHeaderParsingHelpers.TryGetHeaderValue(requestCacheControlHeaders, CacheControlValues.MaxAgeString, out seconds))
                 {
                     requestMaxAge = TimeSpan.FromSeconds(seconds);
                 }
 
                 TimeSpan? cachedMaxAge = null;
-                if (ParsingHelpers.TryGetHeaderValue(cachedControlHeaders, CacheControlValues.MaxAgeString, out seconds))
+                if (HttpHeaderParsingHelpers.TryGetHeaderValue(cachedControlHeaders, CacheControlValues.MaxAgeString, out seconds))
                 {
                     cachedMaxAge = TimeSpan.FromSeconds(seconds);
                 }
@@ -230,17 +203,14 @@ public virtual bool IsCachedEntryFresh(ResponseCacheContext context)
                 if (age >= lowestMaxAge)
                 {
                     // Must revalidate
-                    foreach (var header in cachedControlHeaders)
+                    if (HttpHeaderParsingHelpers.HeaderContains(cachedControlHeaders, CacheControlValues.MustRevalidateString))
                     {
-                        if (header.IndexOf(CacheControlValues.MustRevalidateString, StringComparison.OrdinalIgnoreCase) != -1)
-                        {
-                            context.Logger.LogExpirationMustRevalidate(age, lowestMaxAge.Value);
-                            return false;
-                        }
+                        context.Logger.LogExpirationMustRevalidate(age, lowestMaxAge.Value);
+                        return false;
                     }
 
                     TimeSpan? requestMaxStale = null;
-                    if (ParsingHelpers.TryGetHeaderValue(requestCacheControlHeaders, CacheControlValues.MaxStaleString, out seconds))
+                    if (HttpHeaderParsingHelpers.TryGetHeaderValue(requestCacheControlHeaders, CacheControlValues.MaxStaleString, out seconds))
                     {
                         requestMaxStale = TimeSpan.FromSeconds(seconds);
                     }
@@ -259,14 +229,11 @@ public virtual bool IsCachedEntryFresh(ResponseCacheContext context)
                 {
                     // Validate expiration
                     DateTimeOffset expires;
-                    if (context.CachedResponseHeaders[HeaderNames.Expires].Count > 0 &&
-                        ParsingHelpers.TryParseDate(context.CachedResponseHeaders[HeaderNames.Expires], out expires))
+                    if (HttpHeaderParsingHelpers.TryParseHeaderDate(context.CachedResponseHeaders[HeaderNames.Expires], out expires) &&
+                        context.ResponseTime.Value >= expires)
                     {
-                        if (context.ResponseTime.Value >= expires)
-                        {
-                            context.Logger.LogExpirationExpiresExceeded(context.ResponseTime.Value, expires);
-                            return false;
-                        }
+                        context.Logger.LogExpirationExpiresExceeded(context.ResponseTime.Value, expires);
+                        return false;
                     }
                 }
             }
diff --git a/src/Microsoft.AspNetCore.ResponseCaching/ResponseCacheMiddleware.cs b/src/Microsoft.AspNetCore.ResponseCaching/ResponseCacheMiddleware.cs
@@ -191,14 +191,11 @@ internal async Task<bool> TryServeFromCacheAsync(ResponseCacheContext context)
                 return true;
             }
 
-            foreach (var header in context.HttpContext.Request.Headers[HeaderNames.CacheControl])
+            if (HttpHeaderParsingHelpers.HeaderContains(context.HttpContext.Request.Headers[HeaderNames.CacheControl], CacheControlValues.OnlyIfCachedString))
             {
-                if (header.IndexOf(CacheControlValues.OnlyIfCachedString, StringComparison.OrdinalIgnoreCase) != -1)
-                {
-                    _logger.LogGatewayTimeoutServed();
-                    context.HttpContext.Response.StatusCode = StatusCodes.Status504GatewayTimeout;
-                    return true;
-                }
+                _logger.LogGatewayTimeoutServed();
+                context.HttpContext.Response.StatusCode = StatusCodes.Status504GatewayTimeout;
+                return true;
             }
 
             _logger.LogNoResponseServed();
@@ -379,20 +376,18 @@ internal static bool ContentIsNotModified(ResponseCacheContext context)
                 if (!StringValues.IsNullOrEmpty(ifUnmodifiedSince))
                 {
                     DateTimeOffset modified;
-                    if (!ParsingHelpers.TryParseDate(cachedResponseHeaders[HeaderNames.LastModified], out modified) &&
-                        !ParsingHelpers.TryParseDate(cachedResponseHeaders[HeaderNames.Date], out modified))
+                    if (!HttpHeaderParsingHelpers.TryParseHeaderDate(cachedResponseHeaders[HeaderNames.LastModified], out modified) &&
+                        !HttpHeaderParsingHelpers.TryParseHeaderDate(cachedResponseHeaders[HeaderNames.Date], out modified))
                     {
                         return false;
                     }
 
                     DateTimeOffset unmodifiedSince;
-                    if (ParsingHelpers.TryParseDate(ifUnmodifiedSince, out unmodifiedSince))
+                    if (HttpHeaderParsingHelpers.TryParseHeaderDate(ifUnmodifiedSince, out unmodifiedSince) &&
+                        modified <= unmodifiedSince)
                     {
-                        if (modified <= unmodifiedSince)
-                        {
-                            context.Logger.LogNotModifiedIfUnmodifiedSinceSatisfied(modified, unmodifiedSince);
-                            return true;
-                        }
+                        context.Logger.LogNotModifiedIfUnmodifiedSinceSatisfied(modified, unmodifiedSince);
+                        return true;
                     }
                 }
             }
diff --git a/test/Microsoft.AspNetCore.ResponseCaching.Tests/ParsingHelpersTests.cs b/test/Microsoft.AspNetCore.ResponseCaching.Tests/ParsingHelpersTests.cs
@@ -1,4 +1,7 @@
-﻿using Microsoft.AspNetCore.ResponseCaching.Internal;
+﻿// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using Microsoft.AspNetCore.ResponseCaching.Internal;
 using Microsoft.Extensions.Primitives;
 using Xunit;
 
@@ -15,7 +18,7 @@ public class ParsingHelpersTests
         void TryGetHeaderValue_Succeeds(string headerValue, string headerName, int expectedValue)
         {
             int value;
-            Assert.True(ParsingHelpers.TryGetHeaderValue(new StringValues(headerValue), headerName, out value));
+            Assert.True(HttpHeaderParsingHelpers.TryGetHeaderValue(new StringValues(headerValue), headerName, out value));
             Assert.Equal(expectedValue, value);
         }
 
@@ -29,7 +32,7 @@ void TryGetHeaderValue_Succeeds(string headerValue, string headerName, int expec
         void TryGetHeaderValue_Fails(string headerValue, string headerName)
         {
             int value;
-            Assert.False(ParsingHelpers.TryGetHeaderValue(new StringValues(headerValue), headerName, out value));
+            Assert.False(HttpHeaderParsingHelpers.TryGetHeaderValue(new StringValues(headerValue), headerName, out value));
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ internal DateTimeOffset? ResponseDate`
`65`	`65`	`{`
`66`	`66`	`_parsedResponseDate = true;`
`67`	`67`	`DateTimeOffset date;`
`68`		`- if (ParsingHelpers.TryParseDate(HttpContext.Response.Headers[HeaderNames.Date], out date))`
	`68`	`+ if (HttpHeaderParsingHelpers.TryParseHeaderDate(HttpContext.Response.Headers[HeaderNames.Date], out date))`
`69`	`69`	`{`
`70`	`70`	`_responseDate = date;`
`71`	`71`	`}`
`@@ -92,7 +92,7 @@ internal DateTimeOffset? ResponseExpires`
`92`	`92`	`{`
`93`	`93`	`_parsedResponseExpires = true;`
`94`	`94`	`DateTimeOffset expires;`
`95`		`- if (ParsingHelpers.TryParseDate(HttpContext.Response.Headers[HeaderNames.Expires], out expires))`
	`95`	`+ if (HttpHeaderParsingHelpers.TryParseHeaderDate(HttpContext.Response.Headers[HeaderNames.Expires], out expires))`
`96`	`96`	`{`
`97`	`97`	`_responseExpires = expires;`
`98`	`98`	`}`
`@@ -114,7 +114,7 @@ internal TimeSpan? ResponseSharedMaxAge`
`114`	`114`	`_parsedResponseSharedMaxAge = true;`
`115`	`115`	`_responseSharedMaxAge = null;`
`116`	`116`	`int seconds;`
`117`		`- if (ParsingHelpers.TryGetHeaderValue(HttpContext.Response.Headers[HeaderNames.CacheControl], CacheControlValues.SharedMaxAgeString, out seconds))`
	`117`	`+ if (HttpHeaderParsingHelpers.TryGetHeaderValue(HttpContext.Response.Headers[HeaderNames.CacheControl], CacheControlValues.SharedMaxAgeString, out seconds))`
`118`	`118`	`{`
`119`	`119`	`_responseSharedMaxAge = TimeSpan.FromSeconds(seconds);`
`120`	`120`	`}`
`@@ -132,7 +132,7 @@ internal TimeSpan? ResponseMaxAge`
`132`	`132`	`_parsedResponseMaxAge = true;`
`133`	`133`	`_responseMaxAge = null;`
`134`	`134`	`int seconds;`
`135`		`- if (ParsingHelpers.TryGetHeaderValue(HttpContext.Response.Headers[HeaderNames.CacheControl], CacheControlValues.MaxAgeString, out seconds))`
	`135`	`+ if (HttpHeaderParsingHelpers.TryGetHeaderValue(HttpContext.Response.Headers[HeaderNames.CacheControl], CacheControlValues.MaxAgeString, out seconds))`
`136`	`136`	`{`
`137`	`137`	`_responseMaxAge = TimeSpan.FromSeconds(seconds);`
`138`	`138`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,26 +30,20 @@ public virtual bool IsRequestCacheable(ResponseCacheContext context)`
`30`	`30`	`// Verify request cache-control parameters`
`31`	`31`	`if (!StringValues.IsNullOrEmpty(request.Headers[HeaderNames.CacheControl]))`
`32`	`32`	`{`
`33`		`- foreach (var header in request.Headers[HeaderNames.CacheControl])`
	`33`	`+ if (HttpHeaderParsingHelpers.HeaderContains(request.Headers[HeaderNames.CacheControl], CacheControlValues.NoCacheString))`
`34`	`34`	`{`
`35`		`- if (header.IndexOf(CacheControlValues.NoCacheString, StringComparison.OrdinalIgnoreCase) != -1)`
`36`		`- {`
`37`		`- context.Logger.LogRequestWithNoCacheNotCacheable();`
`38`		`- return false;`
`39`		`- }`
	`35`	`+ context.Logger.LogRequestWithNoCacheNotCacheable();`
	`36`	`+ return false;`
`40`	`37`	`}`
`41`	`38`	`}`
`42`	`39`	`else`
`43`	`40`	`{`
`44`	`41`	`// Support for legacy HTTP 1.0 cache directive`
`45`	`42`	`var pragmaHeaderValues = request.Headers[HeaderNames.Pragma];`
`46`		`- foreach (var directive in pragmaHeaderValues)`
	`43`	`+ if (HttpHeaderParsingHelpers.HeaderContains(request.Headers[HeaderNames.Pragma], CacheControlValues.NoCacheString))`
`47`	`44`	`{`
`48`		`- if (string.Equals(CacheControlValues.NoCacheString, directive, StringComparison.OrdinalIgnoreCase))`
`49`		`- {`
`50`		`- context.Logger.LogRequestWithPragmaNoCacheNotCacheable();`
`51`		`- return false;`
`52`		`- }`
	`45`	`+ context.Logger.LogRequestWithPragmaNoCacheNotCacheable();`
	`46`	`+ return false;`
`53`	`47`	`}`
`54`	`48`	`}`
`55`	`49`
`@@ -61,48 +55,30 @@ public virtual bool IsResponseCacheable(ResponseCacheContext context)`
`61`	`55`	`var responseCacheControlHeader = context.HttpContext.Response.Headers[HeaderNames.CacheControl];`
`62`	`56`
`63`	`57`	`// Only cache pages explicitly marked with public`
`64`		`- var isPublic = false;`
`65`		`- foreach (var header in responseCacheControlHeader)`
`66`		`- {`
`67`		`- if (header.IndexOf(CacheControlValues.PublicString, StringComparison.OrdinalIgnoreCase) != -1)`
`68`		`- {`
`69`		`- isPublic = true;`
`70`		`- break;`
`71`		`- }`
`72`		`- }`
`73`		`- if (!isPublic)`
	`58`	`+ if (!HttpHeaderParsingHelpers.HeaderContains(responseCacheControlHeader, CacheControlValues.PublicString))`
`74`	`59`	`{`
`75`	`60`	`context.Logger.LogResponseWithoutPublicNotCacheable();`
`76`	`61`	`return false;`
`77`	`62`	`}`
`78`	`63`
`79`	`64`	`// Check no-store`
`80`		`- foreach (var header in context.HttpContext.Request.Headers[HeaderNames.CacheControl])`
	`65`	`+ if (HttpHeaderParsingHelpers.HeaderContains(context.HttpContext.Request.Headers[HeaderNames.CacheControl], CacheControlValues.NoStoreString))`
`81`	`66`	`{`
`82`		`- if (header.IndexOf(CacheControlValues.NoStoreString, StringComparison.OrdinalIgnoreCase) != -1)`
`83`		`- {`
`84`		`- context.Logger.LogResponseWithNoStoreNotCacheable();`
`85`		`- return false;`
`86`		`- }`
	`67`	`+ context.Logger.LogResponseWithNoStoreNotCacheable();`
	`68`	`+ return false;`
`87`	`69`	`}`
`88`	`70`
`89`		`- foreach (var header in responseCacheControlHeader)`
	`71`	`+ if (HttpHeaderParsingHelpers.HeaderContains(responseCacheControlHeader, CacheControlValues.NoStoreString))`
`90`	`72`	`{`
`91`		`- if (header.IndexOf(CacheControlValues.NoStoreString, StringComparison.OrdinalIgnoreCase) != -1)`
`92`		`- {`
`93`		`- context.Logger.LogResponseWithNoStoreNotCacheable();`
`94`		`- return false;`
`95`		`- }`
	`73`	`+ context.Logger.LogResponseWithNoStoreNotCacheable();`
	`74`	`+ return false;`
`96`	`75`	`}`
`97`	`76`
`98`	`77`	`// Check no-cache`
`99`		`- foreach (var header in responseCacheControlHeader)`
	`78`	`+ if (HttpHeaderParsingHelpers.HeaderContains(responseCacheControlHeader, CacheControlValues.NoCacheString))`
`100`	`79`	`{`
`101`		`- if (header.IndexOf(CacheControlValues.NoCacheString, StringComparison.OrdinalIgnoreCase) != -1)`
`102`		`- {`
`103`		`- context.Logger.LogResponseWithNoCacheNotCacheable();`
`104`		`- return false;`
`105`		`- }`
	`80`	`+ context.Logger.LogResponseWithNoCacheNotCacheable();`
	`81`	`+ return false;`
`106`	`82`	`}`
`107`	`83`
`108`	`84`	`var response = context.HttpContext.Response;`
`@@ -123,13 +99,10 @@ public virtual bool IsResponseCacheable(ResponseCacheContext context)`
`123`	`99`	`}`
`124`	`100`
`125`	`101`	`// Check private`
`126`		`- foreach (var header in responseCacheControlHeader)`
	`102`	`+ if (HttpHeaderParsingHelpers.HeaderContains(responseCacheControlHeader, CacheControlValues.PrivateString))`
`127`	`103`	`{`
`128`		`- if (header.IndexOf(CacheControlValues.PrivateString, StringComparison.OrdinalIgnoreCase) != -1)`
`129`		`- {`
`130`		`- context.Logger.LogResponseWithPrivateNotCacheable();`
`131`		`- return false;`
`132`		`- }`
	`104`	`+ context.Logger.LogResponseWithPrivateNotCacheable();`
	`105`	`+ return false;`
`133`	`106`	`}`
`134`	`107`
`135`	`108`	`// Check response code`
`@@ -191,7 +164,7 @@ public virtual bool IsCachedEntryFresh(ResponseCacheContext context)`
`191`	`164`
`192`	`165`	`// Add min-fresh requirements`
`193`	`166`	`int seconds;`
`194`		`- if (ParsingHelpers.TryGetHeaderValue(requestCacheControlHeaders, CacheControlValues.MinFreshString, out seconds))`
	`167`	`+ if (HttpHeaderParsingHelpers.TryGetHeaderValue(requestCacheControlHeaders, CacheControlValues.MinFreshString, out seconds))`
`195`	`168`	`{`
`196`	`169`	`var minFresh = TimeSpan.FromSeconds(seconds);`
`197`	`170`	`age += minFresh;`
`@@ -200,7 +173,7 @@ public virtual bool IsCachedEntryFresh(ResponseCacheContext context)`
`200`	`173`
`201`	`174`	`// Validate shared max age, this overrides any max age settings for shared caches`
`202`	`175`	`TimeSpan? cachedSharedMaxAge = null;`
`203`		`- if (ParsingHelpers.TryGetHeaderValue(cachedControlHeaders, CacheControlValues.SharedMaxAgeString, out seconds))`
	`176`	`+ if (HttpHeaderParsingHelpers.TryGetHeaderValue(cachedControlHeaders, CacheControlValues.SharedMaxAgeString, out seconds))`
`204`	`177`	`{`
`205`	`178`	`cachedSharedMaxAge = TimeSpan.FromSeconds(seconds);`
`206`	`179`	`}`
`@@ -214,13 +187,13 @@ public virtual bool IsCachedEntryFresh(ResponseCacheContext context)`
`214`	`187`	`else if (!cachedSharedMaxAge.HasValue)`
`215`	`188`	`{`
`216`	`189`	`TimeSpan? requestMaxAge = null;`
`217`		`- if (ParsingHelpers.TryGetHeaderValue(requestCacheControlHeaders, CacheControlValues.MaxAgeString, out seconds))`
	`190`	`+ if (HttpHeaderParsingHelpers.TryGetHeaderValue(requestCacheControlHeaders, CacheControlValues.MaxAgeString, out seconds))`
`218`	`191`	`{`
`219`	`192`	`requestMaxAge = TimeSpan.FromSeconds(seconds);`
`220`	`193`	`}`
`221`	`194`
`222`	`195`	`TimeSpan? cachedMaxAge = null;`
`223`		`- if (ParsingHelpers.TryGetHeaderValue(cachedControlHeaders, CacheControlValues.MaxAgeString, out seconds))`
	`196`	`+ if (HttpHeaderParsingHelpers.TryGetHeaderValue(cachedControlHeaders, CacheControlValues.MaxAgeString, out seconds))`
`224`	`197`	`{`
`225`	`198`	`cachedMaxAge = TimeSpan.FromSeconds(seconds);`
`226`	`199`	`}`
`@@ -230,17 +203,14 @@ public virtual bool IsCachedEntryFresh(ResponseCacheContext context)`
`230`	`203`	`if (age >= lowestMaxAge)`
`231`	`204`	`{`
`232`	`205`	`// Must revalidate`
`233`		`- foreach (var header in cachedControlHeaders)`
	`206`	`+ if (HttpHeaderParsingHelpers.HeaderContains(cachedControlHeaders, CacheControlValues.MustRevalidateString))`
`234`	`207`	`{`
`235`		`- if (header.IndexOf(CacheControlValues.MustRevalidateString, StringComparison.OrdinalIgnoreCase) != -1)`
`236`		`- {`
`237`		`- context.Logger.LogExpirationMustRevalidate(age, lowestMaxAge.Value);`
`238`		`- return false;`
`239`		`- }`
	`208`	`+ context.Logger.LogExpirationMustRevalidate(age, lowestMaxAge.Value);`
	`209`	`+ return false;`
`240`	`210`	`}`
`241`	`211`
`242`	`212`	`TimeSpan? requestMaxStale = null;`
`243`		`- if (ParsingHelpers.TryGetHeaderValue(requestCacheControlHeaders, CacheControlValues.MaxStaleString, out seconds))`
	`213`	`+ if (HttpHeaderParsingHelpers.TryGetHeaderValue(requestCacheControlHeaders, CacheControlValues.MaxStaleString, out seconds))`
`244`	`214`	`{`
`245`	`215`	`requestMaxStale = TimeSpan.FromSeconds(seconds);`
`246`	`216`	`}`
`@@ -259,14 +229,11 @@ public virtual bool IsCachedEntryFresh(ResponseCacheContext context)`
`259`	`229`	`{`
`260`	`230`	`// Validate expiration`
`261`	`231`	`DateTimeOffset expires;`
`262`		`- if (context.CachedResponseHeaders[HeaderNames.Expires].Count > 0 &&`
`263`		`- ParsingHelpers.TryParseDate(context.CachedResponseHeaders[HeaderNames.Expires], out expires))`
	`232`	`+ if (HttpHeaderParsingHelpers.TryParseHeaderDate(context.CachedResponseHeaders[HeaderNames.Expires], out expires) &&`
	`233`	`+ context.ResponseTime.Value >= expires)`
`264`	`234`	`{`
`265`		`- if (context.ResponseTime.Value >= expires)`
`266`		`- {`
`267`		`- context.Logger.LogExpirationExpiresExceeded(context.ResponseTime.Value, expires);`
`268`		`- return false;`
`269`		`- }`
	`235`	`+ context.Logger.LogExpirationExpiresExceeded(context.ResponseTime.Value, expires);`
	`236`	`+ return false;`
`270`	`237`	`}`
`271`	`238`	`}`
`272`	`239`	`}`
Original file line number	Diff line number	Diff line change
`@@ -191,14 +191,11 @@ internal async Task<bool> TryServeFromCacheAsync(ResponseCacheContext context)`
`191`	`191`	`return true;`
`192`	`192`	`}`
`193`	`193`
`194`		`- foreach (var header in context.HttpContext.Request.Headers[HeaderNames.CacheControl])`
	`194`	`+ if (HttpHeaderParsingHelpers.HeaderContains(context.HttpContext.Request.Headers[HeaderNames.CacheControl], CacheControlValues.OnlyIfCachedString))`
`195`	`195`	`{`
`196`		`- if (header.IndexOf(CacheControlValues.OnlyIfCachedString, StringComparison.OrdinalIgnoreCase) != -1)`
`197`		`- {`
`198`		`- _logger.LogGatewayTimeoutServed();`
`199`		`- context.HttpContext.Response.StatusCode = StatusCodes.Status504GatewayTimeout;`
`200`		`- return true;`
`201`		`- }`
	`196`	`+ _logger.LogGatewayTimeoutServed();`
	`197`	`+ context.HttpContext.Response.StatusCode = StatusCodes.Status504GatewayTimeout;`
	`198`	`+ return true;`
`202`	`199`	`}`
`203`	`200`
`204`	`201`	`_logger.LogNoResponseServed();`
`@@ -379,20 +376,18 @@ internal static bool ContentIsNotModified(ResponseCacheContext context)`
`379`	`376`	`if (!StringValues.IsNullOrEmpty(ifUnmodifiedSince))`
`380`	`377`	`{`
`381`	`378`	`DateTimeOffset modified;`
`382`		`- if (!ParsingHelpers.TryParseDate(cachedResponseHeaders[HeaderNames.LastModified], out modified) &&`
`383`		`- !ParsingHelpers.TryParseDate(cachedResponseHeaders[HeaderNames.Date], out modified))`
	`379`	`+ if (!HttpHeaderParsingHelpers.TryParseHeaderDate(cachedResponseHeaders[HeaderNames.LastModified], out modified) &&`
	`380`	`+ !HttpHeaderParsingHelpers.TryParseHeaderDate(cachedResponseHeaders[HeaderNames.Date], out modified))`
`384`	`381`	`{`
`385`	`382`	`return false;`
`386`	`383`	`}`
`387`	`384`
`388`	`385`	`DateTimeOffset unmodifiedSince;`
`389`		`- if (ParsingHelpers.TryParseDate(ifUnmodifiedSince, out unmodifiedSince))`
	`386`	`+ if (HttpHeaderParsingHelpers.TryParseHeaderDate(ifUnmodifiedSince, out unmodifiedSince) &&`
	`387`	`+ modified <= unmodifiedSince)`
`390`	`388`	`{`
`391`		`- if (modified <= unmodifiedSince)`
`392`		`- {`
`393`		`- context.Logger.LogNotModifiedIfUnmodifiedSinceSatisfied(modified, unmodifiedSince);`
`394`		`- return true;`
`395`		`- }`
	`389`	`+ context.Logger.LogNotModifiedIfUnmodifiedSinceSatisfied(modified, unmodifiedSince);`
	`390`	`+ return true;`
`396`	`391`	`}`
`397`	`392`	`}`
`398`	`393`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,7 @@`
`1`		`-using Microsoft.AspNetCore.ResponseCaching.Internal;`
	`1`	`+// Copyright (c) .NET Foundation. All rights reserved.`
	`2`	`+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.`
	`3`	`+`
	`4`	`+using Microsoft.AspNetCore.ResponseCaching.Internal;`
`2`	`5`	`using Microsoft.Extensions.Primitives;`
`3`	`6`	`using Xunit;`
`4`	`7`
`@@ -15,7 +18,7 @@ public class ParsingHelpersTests`
`15`	`18`	`void TryGetHeaderValue_Succeeds(string headerValue, string headerName, int expectedValue)`
`16`	`19`	`{`
`17`	`20`	`int value;`
`18`		`- Assert.True(ParsingHelpers.TryGetHeaderValue(new StringValues(headerValue), headerName, out value));`
	`21`	`+ Assert.True(HttpHeaderParsingHelpers.TryGetHeaderValue(new StringValues(headerValue), headerName, out value));`
`19`	`22`	`Assert.Equal(expectedValue, value);`
`20`	`23`	`}`
`21`	`24`
`@@ -29,7 +32,7 @@ void TryGetHeaderValue_Succeeds(string headerValue, string headerName, int expec`
`29`	`32`	`void TryGetHeaderValue_Fails(string headerValue, string headerName)`
`30`	`33`	`{`
`31`	`34`	`int value;`
`32`		`- Assert.False(ParsingHelpers.TryGetHeaderValue(new StringValues(headerValue), headerName, out value));`
	`35`	`+ Assert.False(HttpHeaderParsingHelpers.TryGetHeaderValue(new StringValues(headerValue), headerName, out value));`
`33`	`36`	`}`
`34`	`37`	`}`
`35`	`38`	`}`