Add CacheControlValues back

JunTaoLuo · JunTaoLuo · commit 7322d8fad65d · 2016-11-22T16:37:01.000-08:00
diff --git a/src/Microsoft.AspNetCore.ResponseCaching/Internal/CacheControlValues.cs b/src/Microsoft.AspNetCore.ResponseCaching/Internal/CacheControlValues.cs
@@ -0,0 +1,21 @@
+﻿// 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.
+
+namespace Microsoft.AspNetCore.ResponseCaching.Internal
+{
+    internal class CacheControlValues
+    {
+        public const string MaxAgeString = "max-age";
+        public const string MaxStaleString = "max-stale";
+        public const string MinFreshString = "min-fresh";
+        public const string MustRevalidateString = "must-revalidate";
+        public const string NoCacheString = "no-cache";
+        public const string NoStoreString = "no-store";
+        public const string NoTransformString = "no-transform";
+        public const string OnlyIfCachedString = "only-if-cached";
+        public const string PrivateString = "private";
+        public const string ProxyRevalidateString = "proxy-revalidate";
+        public const string PublicString = "public";
+        public const string SharedMaxAgeString = "s-maxage";
+    }
+}
diff --git a/src/Microsoft.AspNetCore.ResponseCaching/Internal/ResponseCachingContext.cs b/src/Microsoft.AspNetCore.ResponseCaching/Internal/ResponseCachingContext.cs
@@ -112,7 +112,7 @@ internal TimeSpan? ResponseSharedMaxAge
                 if (!_parsedResponseSharedMaxAge)
                 {
                     _parsedResponseSharedMaxAge = true;
-                    HeaderUtilities.TryParseTimeSpan(HttpContext.Response.Headers[HeaderNames.CacheControl], CacheControlHeaderValue.SharedMaxAgeString, out _responseSharedMaxAge);
+                    HeaderUtilities.TryParseTimeSpan(HttpContext.Response.Headers[HeaderNames.CacheControl], CacheControlValues.SharedMaxAgeString, out _responseSharedMaxAge);
                 }
                 return _responseSharedMaxAge;
             }
@@ -125,7 +125,7 @@ internal TimeSpan? ResponseMaxAge
                 if (!_parsedResponseMaxAge)
                 {
                     _parsedResponseMaxAge = true;
-                    HeaderUtilities.TryParseTimeSpan(HttpContext.Response.Headers[HeaderNames.CacheControl], CacheControlHeaderValue.MaxAgeString, out _responseMaxAge);
+                    HeaderUtilities.TryParseTimeSpan(HttpContext.Response.Headers[HeaderNames.CacheControl], CacheControlValues.MaxAgeString, out _responseMaxAge);
                 }
                 return _responseMaxAge;
             }
diff --git a/src/Microsoft.AspNetCore.ResponseCaching/Internal/ResponseCachingPolicyProvider.cs b/src/Microsoft.AspNetCore.ResponseCaching/Internal/ResponseCachingPolicyProvider.cs
@@ -30,7 +30,7 @@ public virtual bool IsRequestCacheable(ResponseCachingContext context)
             // Verify request cache-control parameters
             if (!StringValues.IsNullOrEmpty(request.Headers[HeaderNames.CacheControl]))
             {
-                if (HeaderUtilities.Contains(request.Headers[HeaderNames.CacheControl], CacheControlHeaderValue.NoCacheString))
+                if (HeaderUtilities.Contains(request.Headers[HeaderNames.CacheControl], CacheControlValues.NoCacheString))
                 {
                     context.Logger.LogRequestWithNoCacheNotCacheable();
                     return false;
@@ -40,7 +40,7 @@ public virtual bool IsRequestCacheable(ResponseCachingContext context)
             {
                 // Support for legacy HTTP 1.0 cache directive
                 var pragmaHeaderValues = request.Headers[HeaderNames.Pragma];
-                if (HeaderUtilities.Contains(request.Headers[HeaderNames.Pragma], CacheControlHeaderValue.NoCacheString))
+                if (HeaderUtilities.Contains(request.Headers[HeaderNames.Pragma], CacheControlValues.NoCacheString))
                 {
                     context.Logger.LogRequestWithPragmaNoCacheNotCacheable();
                     return false;
@@ -55,22 +55,22 @@ public virtual bool IsResponseCacheable(ResponseCachingContext context)
             var responseCacheControlHeader = context.HttpContext.Response.Headers[HeaderNames.CacheControl];
 
             // Only cache pages explicitly marked with public
-            if (!HeaderUtilities.Contains(responseCacheControlHeader, CacheControlHeaderValue.PublicString))
+            if (!HeaderUtilities.Contains(responseCacheControlHeader, CacheControlValues.PublicString))
             {
                 context.Logger.LogResponseWithoutPublicNotCacheable();
                 return false;
             }
 
             // Check no-store
-            if (HeaderUtilities.Contains(context.HttpContext.Request.Headers[HeaderNames.CacheControl], CacheControlHeaderValue.NoStoreString)
-                || HeaderUtilities.Contains(responseCacheControlHeader, CacheControlHeaderValue.NoStoreString))
+            if (HeaderUtilities.Contains(context.HttpContext.Request.Headers[HeaderNames.CacheControl], CacheControlValues.NoStoreString)
+                || HeaderUtilities.Contains(responseCacheControlHeader, CacheControlValues.NoStoreString))
             {
                 context.Logger.LogResponseWithNoStoreNotCacheable();
                 return false;
             }
 
             // Check no-cache
-            if (HeaderUtilities.Contains(responseCacheControlHeader, CacheControlHeaderValue.NoCacheString))
+            if (HeaderUtilities.Contains(responseCacheControlHeader, CacheControlValues.NoCacheString))
             {
                 context.Logger.LogResponseWithNoCacheNotCacheable();
                 return false;
@@ -94,7 +94,7 @@ public virtual bool IsResponseCacheable(ResponseCachingContext context)
             }
 
             // Check private
-            if (HeaderUtilities.Contains(responseCacheControlHeader, CacheControlHeaderValue.PrivateString))
+            if (HeaderUtilities.Contains(responseCacheControlHeader, CacheControlValues.PrivateString))
             {
                 context.Logger.LogResponseWithPrivateNotCacheable();
                 return false;
@@ -159,15 +159,15 @@ public virtual bool IsCachedEntryFresh(ResponseCachingContext context)
 
             // Add min-fresh requirements
             TimeSpan? minFresh;
-            if (HeaderUtilities.TryParseTimeSpan(requestCacheControlHeaders, CacheControlHeaderValue.MinFreshString, out minFresh))
+            if (HeaderUtilities.TryParseTimeSpan(requestCacheControlHeaders, CacheControlValues.MinFreshString, out minFresh))
             {
                 age += minFresh.Value;
                 context.Logger.LogExpirationMinFreshAdded(minFresh.Value);
             }
 
             // Validate shared max age, this overrides any max age settings for shared caches
             TimeSpan? cachedSharedMaxAge;
-            HeaderUtilities.TryParseTimeSpan(cachedCacheControlHeaders, CacheControlHeaderValue.SharedMaxAgeString, out cachedSharedMaxAge);
+            HeaderUtilities.TryParseTimeSpan(cachedCacheControlHeaders, CacheControlValues.SharedMaxAgeString, out cachedSharedMaxAge);
 
             if (age >= cachedSharedMaxAge)
             {
@@ -178,24 +178,24 @@ public virtual bool IsCachedEntryFresh(ResponseCachingContext context)
             else if (!cachedSharedMaxAge.HasValue)
             {
                 TimeSpan? requestMaxAge;
-                HeaderUtilities.TryParseTimeSpan(requestCacheControlHeaders, CacheControlHeaderValue.MaxAgeString, out requestMaxAge);
+                HeaderUtilities.TryParseTimeSpan(requestCacheControlHeaders, CacheControlValues.MaxAgeString, out requestMaxAge);
 
                 TimeSpan? cachedMaxAge;
-                HeaderUtilities.TryParseTimeSpan(cachedCacheControlHeaders, CacheControlHeaderValue.MaxAgeString, out cachedMaxAge);
+                HeaderUtilities.TryParseTimeSpan(cachedCacheControlHeaders, CacheControlValues.MaxAgeString, out cachedMaxAge);
 
                 var lowestMaxAge = cachedMaxAge < requestMaxAge ? cachedMaxAge : requestMaxAge ?? cachedMaxAge;
                 // Validate max age
                 if (age >= lowestMaxAge)
                 {
                     // Must revalidate
-                    if (HeaderUtilities.Contains(cachedCacheControlHeaders, CacheControlHeaderValue.MustRevalidateString))
+                    if (HeaderUtilities.Contains(cachedCacheControlHeaders, CacheControlValues.MustRevalidateString))
                     {
                         context.Logger.LogExpirationMustRevalidate(age, lowestMaxAge.Value);
                         return false;
                     }
 
                     TimeSpan? requestMaxStale;
-                    HeaderUtilities.TryParseTimeSpan(requestCacheControlHeaders, CacheControlHeaderValue.MaxStaleString, out requestMaxStale);
+                    HeaderUtilities.TryParseTimeSpan(requestCacheControlHeaders, CacheControlValues.MaxStaleString, out requestMaxStale);
 
                     // Request allows stale values
                     if (requestMaxStale.HasValue && age - lowestMaxAge < requestMaxStale)

Original file line number	Diff line number	Diff line change
`@@ -112,7 +112,7 @@ internal TimeSpan? ResponseSharedMaxAge`
`112`	`112`	`if (!_parsedResponseSharedMaxAge)`
`113`	`113`	`{`
`114`	`114`	`_parsedResponseSharedMaxAge = true;`
`115`		`- HeaderUtilities.TryParseTimeSpan(HttpContext.Response.Headers[HeaderNames.CacheControl], CacheControlHeaderValue.SharedMaxAgeString, out _responseSharedMaxAge);`
	`115`	`+ HeaderUtilities.TryParseTimeSpan(HttpContext.Response.Headers[HeaderNames.CacheControl], CacheControlValues.SharedMaxAgeString, out _responseSharedMaxAge);`
`116`	`116`	`}`
`117`	`117`	`return _responseSharedMaxAge;`
`118`	`118`	`}`
`@@ -125,7 +125,7 @@ internal TimeSpan? ResponseMaxAge`
`125`	`125`	`if (!_parsedResponseMaxAge)`
`126`	`126`	`{`
`127`	`127`	`_parsedResponseMaxAge = true;`
`128`		`- HeaderUtilities.TryParseTimeSpan(HttpContext.Response.Headers[HeaderNames.CacheControl], CacheControlHeaderValue.MaxAgeString, out _responseMaxAge);`
	`128`	`+ HeaderUtilities.TryParseTimeSpan(HttpContext.Response.Headers[HeaderNames.CacheControl], CacheControlValues.MaxAgeString, out _responseMaxAge);`
`129`	`129`	`}`
`130`	`130`	`return _responseMaxAge;`
`131`	`131`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ public virtual bool IsRequestCacheable(ResponseCachingContext context)`
`30`	`30`	`// Verify request cache-control parameters`
`31`	`31`	`if (!StringValues.IsNullOrEmpty(request.Headers[HeaderNames.CacheControl]))`
`32`	`32`	`{`
`33`		`- if (HeaderUtilities.Contains(request.Headers[HeaderNames.CacheControl], CacheControlHeaderValue.NoCacheString))`
	`33`	`+ if (HeaderUtilities.Contains(request.Headers[HeaderNames.CacheControl], CacheControlValues.NoCacheString))`
`34`	`34`	`{`
`35`	`35`	`context.Logger.LogRequestWithNoCacheNotCacheable();`
`36`	`36`	`return false;`
`@@ -40,7 +40,7 @@ public virtual bool IsRequestCacheable(ResponseCachingContext context)`
`40`	`40`	`{`
`41`	`41`	`// Support for legacy HTTP 1.0 cache directive`
`42`	`42`	`var pragmaHeaderValues = request.Headers[HeaderNames.Pragma];`
`43`		`- if (HeaderUtilities.Contains(request.Headers[HeaderNames.Pragma], CacheControlHeaderValue.NoCacheString))`
	`43`	`+ if (HeaderUtilities.Contains(request.Headers[HeaderNames.Pragma], CacheControlValues.NoCacheString))`
`44`	`44`	`{`
`45`	`45`	`context.Logger.LogRequestWithPragmaNoCacheNotCacheable();`
`46`	`46`	`return false;`
`@@ -55,22 +55,22 @@ public virtual bool IsResponseCacheable(ResponseCachingContext context)`
`55`	`55`	`var responseCacheControlHeader = context.HttpContext.Response.Headers[HeaderNames.CacheControl];`
`56`	`56`
`57`	`57`	`// Only cache pages explicitly marked with public`
`58`		`- if (!HeaderUtilities.Contains(responseCacheControlHeader, CacheControlHeaderValue.PublicString))`
	`58`	`+ if (!HeaderUtilities.Contains(responseCacheControlHeader, CacheControlValues.PublicString))`
`59`	`59`	`{`
`60`	`60`	`context.Logger.LogResponseWithoutPublicNotCacheable();`
`61`	`61`	`return false;`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`// Check no-store`
`65`		`- if (HeaderUtilities.Contains(context.HttpContext.Request.Headers[HeaderNames.CacheControl], CacheControlHeaderValue.NoStoreString)`
`66`		`- \|\| HeaderUtilities.Contains(responseCacheControlHeader, CacheControlHeaderValue.NoStoreString))`
	`65`	`+ if (HeaderUtilities.Contains(context.HttpContext.Request.Headers[HeaderNames.CacheControl], CacheControlValues.NoStoreString)`
	`66`	`+ \|\| HeaderUtilities.Contains(responseCacheControlHeader, CacheControlValues.NoStoreString))`
`67`	`67`	`{`
`68`	`68`	`context.Logger.LogResponseWithNoStoreNotCacheable();`
`69`	`69`	`return false;`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`// Check no-cache`
`73`		`- if (HeaderUtilities.Contains(responseCacheControlHeader, CacheControlHeaderValue.NoCacheString))`
	`73`	`+ if (HeaderUtilities.Contains(responseCacheControlHeader, CacheControlValues.NoCacheString))`
`74`	`74`	`{`
`75`	`75`	`context.Logger.LogResponseWithNoCacheNotCacheable();`
`76`	`76`	`return false;`
`@@ -94,7 +94,7 @@ public virtual bool IsResponseCacheable(ResponseCachingContext context)`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`// Check private`
`97`		`- if (HeaderUtilities.Contains(responseCacheControlHeader, CacheControlHeaderValue.PrivateString))`
	`97`	`+ if (HeaderUtilities.Contains(responseCacheControlHeader, CacheControlValues.PrivateString))`
`98`	`98`	`{`
`99`	`99`	`context.Logger.LogResponseWithPrivateNotCacheable();`
`100`	`100`	`return false;`
`@@ -159,15 +159,15 @@ public virtual bool IsCachedEntryFresh(ResponseCachingContext context)`
`159`	`159`
`160`	`160`	`// Add min-fresh requirements`
`161`	`161`	`TimeSpan? minFresh;`
`162`		`- if (HeaderUtilities.TryParseTimeSpan(requestCacheControlHeaders, CacheControlHeaderValue.MinFreshString, out minFresh))`
	`162`	`+ if (HeaderUtilities.TryParseTimeSpan(requestCacheControlHeaders, CacheControlValues.MinFreshString, out minFresh))`
`163`	`163`	`{`
`164`	`164`	`age += minFresh.Value;`
`165`	`165`	`context.Logger.LogExpirationMinFreshAdded(minFresh.Value);`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`// Validate shared max age, this overrides any max age settings for shared caches`
`169`	`169`	`TimeSpan? cachedSharedMaxAge;`
`170`		`- HeaderUtilities.TryParseTimeSpan(cachedCacheControlHeaders, CacheControlHeaderValue.SharedMaxAgeString, out cachedSharedMaxAge);`
	`170`	`+ HeaderUtilities.TryParseTimeSpan(cachedCacheControlHeaders, CacheControlValues.SharedMaxAgeString, out cachedSharedMaxAge);`
`171`	`171`
`172`	`172`	`if (age >= cachedSharedMaxAge)`
`173`	`173`	`{`
`@@ -178,24 +178,24 @@ public virtual bool IsCachedEntryFresh(ResponseCachingContext context)`
`178`	`178`	`else if (!cachedSharedMaxAge.HasValue)`
`179`	`179`	`{`
`180`	`180`	`TimeSpan? requestMaxAge;`
`181`		`- HeaderUtilities.TryParseTimeSpan(requestCacheControlHeaders, CacheControlHeaderValue.MaxAgeString, out requestMaxAge);`
	`181`	`+ HeaderUtilities.TryParseTimeSpan(requestCacheControlHeaders, CacheControlValues.MaxAgeString, out requestMaxAge);`
`182`	`182`
`183`	`183`	`TimeSpan? cachedMaxAge;`
`184`		`- HeaderUtilities.TryParseTimeSpan(cachedCacheControlHeaders, CacheControlHeaderValue.MaxAgeString, out cachedMaxAge);`
	`184`	`+ HeaderUtilities.TryParseTimeSpan(cachedCacheControlHeaders, CacheControlValues.MaxAgeString, out cachedMaxAge);`
`185`	`185`
`186`	`186`	`var lowestMaxAge = cachedMaxAge < requestMaxAge ? cachedMaxAge : requestMaxAge ?? cachedMaxAge;`
`187`	`187`	`// Validate max age`
`188`	`188`	`if (age >= lowestMaxAge)`
`189`	`189`	`{`
`190`	`190`	`// Must revalidate`
`191`		`- if (HeaderUtilities.Contains(cachedCacheControlHeaders, CacheControlHeaderValue.MustRevalidateString))`
	`191`	`+ if (HeaderUtilities.Contains(cachedCacheControlHeaders, CacheControlValues.MustRevalidateString))`
`192`	`192`	`{`
`193`	`193`	`context.Logger.LogExpirationMustRevalidate(age, lowestMaxAge.Value);`
`194`	`194`	`return false;`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`TimeSpan? requestMaxStale;`
`198`		`- HeaderUtilities.TryParseTimeSpan(requestCacheControlHeaders, CacheControlHeaderValue.MaxStaleString, out requestMaxStale);`
	`198`	`+ HeaderUtilities.TryParseTimeSpan(requestCacheControlHeaders, CacheControlValues.MaxStaleString, out requestMaxStale);`
`199`	`199`
`200`	`200`	`// Request allows stale values`
`201`	`201`	`if (requestMaxStale.HasValue && age - lowestMaxAge < requestMaxStale)`