Check Accept-Encoding headers before creating compression provider (#154)

pakrym · web-flow · commit f0b44ac7b51f · 2016-10-27T14:12:59.000-07:00
diff --git a/src/Microsoft.AspNetCore.ResponseCompression/BodyWrapperStream.cs b/src/Microsoft.AspNetCore.ResponseCompression/BodyWrapperStream.cs
@@ -17,23 +17,24 @@ namespace Microsoft.AspNetCore.ResponseCompression
     /// </summary>
     internal class BodyWrapperStream : Stream, IHttpBufferingFeature, IHttpSendFileFeature
     {
-        private readonly HttpResponse _response;
+        private readonly HttpContext _context;
         private readonly Stream _bodyOriginalStream;
         private readonly IResponseCompressionProvider _provider;
-        private readonly ICompressionProvider _compressionProvider;
         private readonly IHttpBufferingFeature _innerBufferFeature;
         private readonly IHttpSendFileFeature _innerSendFileFeature;
 
+        private ICompressionProvider _compressionProvider = null;
         private bool _compressionChecked = false;
         private Stream _compressionStream = null;
+        private bool _providerCreated = false;
+        private bool _autoFlush = false;
 
-        internal BodyWrapperStream(HttpResponse response, Stream bodyOriginalStream, IResponseCompressionProvider provider, ICompressionProvider compressionProvider,
+        internal BodyWrapperStream(HttpContext context, Stream bodyOriginalStream, IResponseCompressionProvider provider,
             IHttpBufferingFeature innerBufferFeature, IHttpSendFileFeature innerSendFileFeature)
         {
-            _response = response;
+            _context = context;
             _bodyOriginalStream = bodyOriginalStream;
             _provider = provider;
-            _compressionProvider = compressionProvider;
             _innerBufferFeature = innerBufferFeature;
             _innerSendFileFeature = innerSendFileFeature;
         }
@@ -125,6 +126,10 @@ public override void Write(byte[] buffer, int offset, int count)
             if (_compressionStream != null)
             {
                 _compressionStream.Write(buffer, offset, count);
+                if (_autoFlush)
+                {
+                    _compressionStream.Flush();
+                }
             }
             else
             {
@@ -133,67 +138,101 @@ public override void Write(byte[] buffer, int offset, int count)
         }
 
 #if NET451
-        public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
+        public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, Object state)
         {
-            OnWrite();
-
-            if (_compressionStream != null)
-            {
-                return _compressionStream.BeginWrite(buffer, offset, count, callback, state);
-            }
-            return _bodyOriginalStream.BeginWrite(buffer, offset, count, callback, state);
+            var tcs = new TaskCompletionSource<object>(state);
+            InternalWriteAsync(buffer, offset, count, callback, tcs);
+            return tcs.Task;
         }
 
-        public override void EndWrite(IAsyncResult asyncResult)
+        private async void InternalWriteAsync(byte[] buffer, int offset, int count, AsyncCallback callback, TaskCompletionSource<object> tcs)
         {
-            if (!_compressionChecked)
+            try
             {
-                throw new InvalidOperationException("BeginWrite was not called before EndWrite");
+                await WriteAsync(buffer, offset, count);
+                tcs.TrySetResult(null);
+            }
+            catch (Exception ex)
+            {
+                tcs.TrySetException(ex);
             }
 
-            if (_compressionStream != null)
+            if (callback != null)
             {
-                _compressionStream.EndWrite(asyncResult);
+                // Offload callbacks to avoid stack dives on sync completions.
+                var ignored = Task.Run(() =>
+                {
+                    try
+                    {
+                        callback(tcs.Task);
+                    }
+                    catch (Exception)
+                    {
+                        // Suppress exceptions on background threads.
+                    }
+                });
             }
-            else
+        }
+
+        public override void EndWrite(IAsyncResult asyncResult)
+        {
+            if (asyncResult == null)
             {
-                _bodyOriginalStream.EndWrite(asyncResult);
+                throw new ArgumentNullException(nameof(asyncResult));
             }
+
+            var task = (Task)asyncResult;
+            task.GetAwaiter().GetResult();
         }
 #endif
 
-        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
         {
             OnWrite();
 
             if (_compressionStream != null)
             {
-                return _compressionStream.WriteAsync(buffer, offset, count, cancellationToken);
+                await _compressionStream.WriteAsync(buffer, offset, count, cancellationToken);
+                if (_autoFlush)
+                {
+                    await _compressionStream.FlushAsync(cancellationToken);
+                }
+            }
+            else
+            {
+                await _bodyOriginalStream.WriteAsync(buffer, offset, count, cancellationToken);
             }
-            return _bodyOriginalStream.WriteAsync(buffer, offset, count, cancellationToken);
         }
 
         private void OnWrite()
         {
             if (!_compressionChecked)
             {
                 _compressionChecked = true;
-
-                if (IsCompressable())
+                if (_provider.ShouldCompressResponse(_context))
                 {
-                    _response.Headers.Append(HeaderNames.ContentEncoding, _compressionProvider.EncodingName);
-                    _response.Headers.Remove(HeaderNames.ContentMD5); // Reset the MD5 because the content changed.
-                    _response.Headers.Remove(HeaderNames.ContentLength);
-
-                    _compressionStream = _compressionProvider.CreateStream(_bodyOriginalStream);
+                    var compressionProvider = ResolveCompressionProvider();
+                    if (compressionProvider != null)
+                    {
+                        _context.Response.Headers.Append(HeaderNames.ContentEncoding, compressionProvider.EncodingName);
+                        _context.Response.Headers.Remove(HeaderNames.ContentMD5); // Reset the MD5 because the content changed.
+                        _context.Response.Headers.Remove(HeaderNames.ContentLength);
+
+                        _compressionStream = compressionProvider.CreateStream(_bodyOriginalStream);
+                    }
                 }
             }
         }
 
-        private bool IsCompressable()
+        private ICompressionProvider ResolveCompressionProvider()
         {
-            return !_response.Headers.ContainsKey(HeaderNames.ContentRange) &&     // The response is not partial
-                _provider.ShouldCompressResponse(_response.HttpContext);
+            if (!_providerCreated)
+            {
+                _providerCreated = true;
+                _compressionProvider = _provider.GetCompressionProvider(_context);
+            }
+
+            return _compressionProvider;
         }
 
         public void DisableRequestBuffering()
@@ -205,13 +244,16 @@ public void DisableRequestBuffering()
         // For this to be effective it needs to be called before the first write.
         public void DisableResponseBuffering()
         {
-            if (!_compressionProvider.SupportsFlush)
+            if (ResolveCompressionProvider()?.SupportsFlush == false)
             {
                 // Don't compress, some of the providers don't implement Flush (e.g. .NET 4.5.1 GZip/Deflate stream)
                 // which would block real-time responses like SignalR.
                 _compressionChecked = true;
             }
-
+            else
+            {
+                _autoFlush = true;
+            }
             _innerBufferFeature?.DisableResponseBuffering();
         }
 
@@ -257,6 +299,11 @@ private async Task InnerSendFileAsync(string path, long offset, long? count, Can
             {
                 fileStream.Seek(offset, SeekOrigin.Begin);
                 await StreamCopyOperation.CopyToAsync(fileStream, _compressionStream, count, cancellation);
+
+                if (_autoFlush)
+                {
+                    await _compressionStream.FlushAsync(cancellation);
+                }
             }
         }
     }
diff --git a/src/Microsoft.AspNetCore.ResponseCompression/IResponseCompressionProvider.cs b/src/Microsoft.AspNetCore.ResponseCompression/IResponseCompressionProvider.cs
@@ -23,5 +23,12 @@ public interface IResponseCompressionProvider
         /// <param name="context"></param>
         /// <returns></returns>
         bool ShouldCompressResponse(HttpContext context);
+
+        /// <summary>
+        /// Examines the request to see if compression should be used for response.
+        /// </summary>
+        /// <param name="context"></param>
+        /// <returns></returns>
+        bool CheckRequestAcceptsCompression(HttpContext context);
     }
 }
diff --git a/src/Microsoft.AspNetCore.ResponseCompression/Properties/AssemblyInfo.cs b/src/Microsoft.AspNetCore.ResponseCompression/Properties/AssemblyInfo.cs
@@ -3,6 +3,9 @@
 
 using System.Reflection;
 using System.Resources;
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Microsoft.AspNetCore.ResponseCompression.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
 
 [assembly: AssemblyMetadata("Serviceable", "True")]
 [assembly: NeutralResourcesLanguage("en-us")]
diff --git a/src/Microsoft.AspNetCore.ResponseCompression/ResponseCompressionMiddleware.cs b/src/Microsoft.AspNetCore.ResponseCompression/ResponseCompressionMiddleware.cs
@@ -18,15 +18,13 @@ public class ResponseCompressionMiddleware
 
         private readonly IResponseCompressionProvider _provider;
 
-        private readonly bool _enableForHttps;
 
         /// <summary>
         /// Initialize the Response Compression middleware.
         /// </summary>
         /// <param name="next"></param>
         /// <param name="provider"></param>
-        /// <param name="options"></param>
-        public ResponseCompressionMiddleware(RequestDelegate next, IResponseCompressionProvider provider, IOptions<ResponseCompressionOptions> options)
+        public ResponseCompressionMiddleware(RequestDelegate next, IResponseCompressionProvider provider)
         {
             if (next == null)
             {
@@ -36,14 +34,9 @@ public ResponseCompressionMiddleware(RequestDelegate next, IResponseCompressionP
             {
                 throw new ArgumentNullException(nameof(provider));
             }
-            if (options == null)
-            {
-                throw new ArgumentNullException(nameof(options));
-            }
 
             _next = next;
             _provider = provider;
-            _enableForHttps = options.Value.EnableForHttps;
         }
 
         /// <summary>
@@ -53,14 +46,7 @@ public ResponseCompressionMiddleware(RequestDelegate next, IResponseCompressionP
         /// <returns></returns>
         public async Task Invoke(HttpContext context)
         {
-            ICompressionProvider compressionProvider = null;
-
-            if (!context.Request.IsHttps || _enableForHttps)
-            {
-                compressionProvider = _provider.GetCompressionProvider(context);
-            }
-
-            if (compressionProvider == null)
+            if (!_provider.CheckRequestAcceptsCompression(context))
             {
                 await _next(context);
                 return;
@@ -70,7 +56,7 @@ public async Task Invoke(HttpContext context)
             var originalBufferFeature = context.Features.Get<IHttpBufferingFeature>();
             var originalSendFileFeature = context.Features.Get<IHttpSendFileFeature>();
 
-            var bodyWrapperStream = new BodyWrapperStream(context.Response, bodyStream, _provider, compressionProvider,
+            var bodyWrapperStream = new BodyWrapperStream(context, bodyStream, _provider,
                 originalBufferFeature, originalSendFileFeature);
             context.Response.Body = bodyWrapperStream;
             context.Features.Set<IHttpBufferingFeature>(bodyWrapperStream);
diff --git a/src/Microsoft.AspNetCore.ResponseCompression/ResponseCompressionProvider.cs b/src/Microsoft.AspNetCore.ResponseCompression/ResponseCompressionProvider.cs
@@ -16,6 +16,7 @@ public class ResponseCompressionProvider : IResponseCompressionProvider
     {
         private readonly ICompressionProvider[] _providers;
         private readonly HashSet<string> _mimeTypes;
+        private readonly bool _enableForHttps;
 
         /// <summary>
         /// If no compression providers are specified then GZip is used by default.
@@ -54,6 +55,8 @@ public ResponseCompressionProvider(IServiceProvider services, IOptions<ResponseC
                 mimeTypes = ResponseCompressionDefaults.MimeTypes;
             }
             _mimeTypes = new HashSet<string>(mimeTypes, StringComparer.OrdinalIgnoreCase);
+
+            _enableForHttps = options.Value.EnableForHttps;
         }
 
         /// <inheritdoc />
@@ -103,6 +106,11 @@ public virtual ICompressionProvider GetCompressionProvider(HttpContext context)
         /// <inheritdoc />
         public virtual bool ShouldCompressResponse(HttpContext context)
         {
+            if (context.Response.Headers.ContainsKey(HeaderNames.ContentRange))
+            {
+                return false;
+            }
+
             var mimeType = context.Response.ContentType;
 
             if (string.IsNullOrEmpty(mimeType))
@@ -121,5 +129,15 @@ public virtual bool ShouldCompressResponse(HttpContext context)
             // TODO PERF: StringSegments?
             return _mimeTypes.Contains(mimeType);
         }
+
+        /// <inheritdoc />
+        public bool CheckRequestAcceptsCompression(HttpContext context)
+        {
+            if (context.Request.IsHttps && !_enableForHttps)
+            {
+                return false;
+            }
+            return !string.IsNullOrEmpty(context.Request.Headers[HeaderNames.AcceptEncoding]);
+        }
     }
 }
diff --git a/test/Microsoft.AspNetCore.ResponseCompression.Tests/BodyWrapperStreamTests.cs b/test/Microsoft.AspNetCore.ResponseCompression.Tests/BodyWrapperStreamTests.cs
diff --git a/test/Microsoft.AspNetCore.ResponseCompression.Tests/project.json b/test/Microsoft.AspNetCore.ResponseCompression.Tests/project.json

Original file line number	Diff line number	Diff line change
`@@ -17,23 +17,24 @@ namespace Microsoft.AspNetCore.ResponseCompression`
`17`	`17`	`/// </summary>`
`18`	`18`	`internal class BodyWrapperStream : Stream, IHttpBufferingFeature, IHttpSendFileFeature`
`19`	`19`	`{`
`20`		`- private readonly HttpResponse _response;`
	`20`	`+ private readonly HttpContext _context;`
`21`	`21`	`private readonly Stream _bodyOriginalStream;`
`22`	`22`	`private readonly IResponseCompressionProvider _provider;`
`23`		`- private readonly ICompressionProvider _compressionProvider;`
`24`	`23`	`private readonly IHttpBufferingFeature _innerBufferFeature;`
`25`	`24`	`private readonly IHttpSendFileFeature _innerSendFileFeature;`
`26`	`25`
	`26`	`+ private ICompressionProvider _compressionProvider = null;`
`27`	`27`	`private bool _compressionChecked = false;`
`28`	`28`	`private Stream _compressionStream = null;`
	`29`	`+ private bool _providerCreated = false;`
	`30`	`+ private bool _autoFlush = false;`
`29`	`31`
`30`		`- internal BodyWrapperStream(HttpResponse response, Stream bodyOriginalStream, IResponseCompressionProvider provider, ICompressionProvider compressionProvider,`
	`32`	`+ internal BodyWrapperStream(HttpContext context, Stream bodyOriginalStream, IResponseCompressionProvider provider,`
`31`	`33`	`IHttpBufferingFeature innerBufferFeature, IHttpSendFileFeature innerSendFileFeature)`
`32`	`34`	`{`
`33`		`- _response = response;`
	`35`	`+ _context = context;`
`34`	`36`	`_bodyOriginalStream = bodyOriginalStream;`
`35`	`37`	`_provider = provider;`
`36`		`- _compressionProvider = compressionProvider;`
`37`	`38`	`_innerBufferFeature = innerBufferFeature;`
`38`	`39`	`_innerSendFileFeature = innerSendFileFeature;`
`39`	`40`	`}`
`@@ -125,6 +126,10 @@ public override void Write(byte[] buffer, int offset, int count)`
`125`	`126`	`if (_compressionStream != null)`
`126`	`127`	`{`
`127`	`128`	`_compressionStream.Write(buffer, offset, count);`
	`129`	`+ if (_autoFlush)`
	`130`	`+ {`
	`131`	`+ _compressionStream.Flush();`
	`132`	`+ }`
`128`	`133`	`}`
`129`	`134`	`else`
`130`	`135`	`{`
`@@ -133,67 +138,101 @@ public override void Write(byte[] buffer, int offset, int count)`
`133`	`138`	`}`
`134`	`139`
`135`	`140`	`#if NET451`
`136`		`- public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)`
	`141`	`+ public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, Object state)`
`137`	`142`	`{`
`138`		`- OnWrite();`
`139`		`-`
`140`		`- if (_compressionStream != null)`
`141`		`- {`
`142`		`- return _compressionStream.BeginWrite(buffer, offset, count, callback, state);`
`143`		`- }`
`144`		`- return _bodyOriginalStream.BeginWrite(buffer, offset, count, callback, state);`
	`143`	`+ var tcs = new TaskCompletionSource<object>(state);`
	`144`	`+ InternalWriteAsync(buffer, offset, count, callback, tcs);`
	`145`	`+ return tcs.Task;`
`145`	`146`	`}`
`146`	`147`
`147`		`- public override void EndWrite(IAsyncResult asyncResult)`
	`148`	`+ private async void InternalWriteAsync(byte[] buffer, int offset, int count, AsyncCallback callback, TaskCompletionSource<object> tcs)`
`148`	`149`	`{`
`149`		`- if (!_compressionChecked)`
	`150`	`+ try`
`150`	`151`	`{`
`151`		`- throw new InvalidOperationException("BeginWrite was not called before EndWrite");`
	`152`	`+ await WriteAsync(buffer, offset, count);`
	`153`	`+ tcs.TrySetResult(null);`
	`154`	`+ }`
	`155`	`+ catch (Exception ex)`
	`156`	`+ {`
	`157`	`+ tcs.TrySetException(ex);`
`152`	`158`	`}`
`153`	`159`
`154`		`- if (_compressionStream != null)`
	`160`	`+ if (callback != null)`
`155`	`161`	`{`
`156`		`- _compressionStream.EndWrite(asyncResult);`
	`162`	`+ // Offload callbacks to avoid stack dives on sync completions.`
	`163`	`+ var ignored = Task.Run(() =>`
	`164`	`+ {`
	`165`	`+ try`
	`166`	`+ {`
	`167`	`+ callback(tcs.Task);`
	`168`	`+ }`
	`169`	`+ catch (Exception)`
	`170`	`+ {`
	`171`	`+ // Suppress exceptions on background threads.`
	`172`	`+ }`
	`173`	`+ });`
`157`	`174`	`}`
`158`		`- else`
	`175`	`+ }`
	`176`	`+`
	`177`	`+ public override void EndWrite(IAsyncResult asyncResult)`
	`178`	`+ {`
	`179`	`+ if (asyncResult == null)`
`159`	`180`	`{`
`160`		`- _bodyOriginalStream.EndWrite(asyncResult);`
	`181`	`+ throw new ArgumentNullException(nameof(asyncResult));`
`161`	`182`	`}`
	`183`	`+`
	`184`	`+ var task = (Task)asyncResult;`
	`185`	`+ task.GetAwaiter().GetResult();`
`162`	`186`	`}`
`163`	`187`	`#endif`
`164`	`188`
`165`		`- public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)`
	`189`	`+ public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)`
`166`	`190`	`{`
`167`	`191`	`OnWrite();`
`168`	`192`
`169`	`193`	`if (_compressionStream != null)`
`170`	`194`	`{`
`171`		`- return _compressionStream.WriteAsync(buffer, offset, count, cancellationToken);`
	`195`	`+ await _compressionStream.WriteAsync(buffer, offset, count, cancellationToken);`
	`196`	`+ if (_autoFlush)`
	`197`	`+ {`
	`198`	`+ await _compressionStream.FlushAsync(cancellationToken);`
	`199`	`+ }`
	`200`	`+ }`
	`201`	`+ else`
	`202`	`+ {`
	`203`	`+ await _bodyOriginalStream.WriteAsync(buffer, offset, count, cancellationToken);`
`172`	`204`	`}`
`173`		`- return _bodyOriginalStream.WriteAsync(buffer, offset, count, cancellationToken);`
`174`	`205`	`}`
`175`	`206`
`176`	`207`	`private void OnWrite()`
`177`	`208`	`{`
`178`	`209`	`if (!_compressionChecked)`
`179`	`210`	`{`
`180`	`211`	`_compressionChecked = true;`
`181`		`-`
`182`		`- if (IsCompressable())`
	`212`	`+ if (_provider.ShouldCompressResponse(_context))`
`183`	`213`	`{`
`184`		`- _response.Headers.Append(HeaderNames.ContentEncoding, _compressionProvider.EncodingName);`
`185`		`- _response.Headers.Remove(HeaderNames.ContentMD5); // Reset the MD5 because the content changed.`
`186`		`- _response.Headers.Remove(HeaderNames.ContentLength);`
`187`		`-`
`188`		`- _compressionStream = _compressionProvider.CreateStream(_bodyOriginalStream);`
	`214`	`+ var compressionProvider = ResolveCompressionProvider();`
	`215`	`+ if (compressionProvider != null)`
	`216`	`+ {`
	`217`	`+ _context.Response.Headers.Append(HeaderNames.ContentEncoding, compressionProvider.EncodingName);`
	`218`	`+ _context.Response.Headers.Remove(HeaderNames.ContentMD5); // Reset the MD5 because the content changed.`
	`219`	`+ _context.Response.Headers.Remove(HeaderNames.ContentLength);`
	`220`	`+`
	`221`	`+ _compressionStream = compressionProvider.CreateStream(_bodyOriginalStream);`
	`222`	`+ }`
`189`	`223`	`}`
`190`	`224`	`}`
`191`	`225`	`}`
`192`	`226`
`193`		`- private bool IsCompressable()`
	`227`	`+ private ICompressionProvider ResolveCompressionProvider()`
`194`	`228`	`{`
`195`		`- return !_response.Headers.ContainsKey(HeaderNames.ContentRange) && // The response is not partial`
`196`		`- _provider.ShouldCompressResponse(_response.HttpContext);`
	`229`	`+ if (!_providerCreated)`
	`230`	`+ {`
	`231`	`+ _providerCreated = true;`
	`232`	`+ _compressionProvider = _provider.GetCompressionProvider(_context);`
	`233`	`+ }`
	`234`	`+`
	`235`	`+ return _compressionProvider;`
`197`	`236`	`}`
`198`	`237`
`199`	`238`	`public void DisableRequestBuffering()`
`@@ -205,13 +244,16 @@ public void DisableRequestBuffering()`
`205`	`244`	`// For this to be effective it needs to be called before the first write.`
`206`	`245`	`public void DisableResponseBuffering()`
`207`	`246`	`{`
`208`		`- if (!_compressionProvider.SupportsFlush)`
	`247`	`+ if (ResolveCompressionProvider()?.SupportsFlush == false)`
`209`	`248`	`{`
`210`	`249`	`// Don't compress, some of the providers don't implement Flush (e.g. .NET 4.5.1 GZip/Deflate stream)`
`211`	`250`	`// which would block real-time responses like SignalR.`
`212`	`251`	`_compressionChecked = true;`
`213`	`252`	`}`
`214`		`-`
	`253`	`+ else`
	`254`	`+ {`
	`255`	`+ _autoFlush = true;`
	`256`	`+ }`
`215`	`257`	`_innerBufferFeature?.DisableResponseBuffering();`
`216`	`258`	`}`
`217`	`259`
`@@ -257,6 +299,11 @@ private async Task InnerSendFileAsync(string path, long offset, long? count, Can`
`257`	`299`	`{`
`258`	`300`	`fileStream.Seek(offset, SeekOrigin.Begin);`
`259`	`301`	`await StreamCopyOperation.CopyToAsync(fileStream, _compressionStream, count, cancellation);`
	`302`	`+`
	`303`	`+ if (_autoFlush)`
	`304`	`+ {`
	`305`	`+ await _compressionStream.FlushAsync(cancellation);`
	`306`	`+ }`
`260`	`307`	`}`
`261`	`308`	`}`
`262`	`309`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,5 +23,12 @@ public interface IResponseCompressionProvider`
`23`	`23`	`/// <param name="context"></param>`
`24`	`24`	`/// <returns></returns>`
`25`	`25`	`bool ShouldCompressResponse(HttpContext context);`
	`26`	`+`
	`27`	`+ /// <summary>`
	`28`	`+ /// Examines the request to see if compression should be used for response.`
	`29`	`+ /// </summary>`
	`30`	`+ /// <param name="context"></param>`
	`31`	`+ /// <returns></returns>`
	`32`	`+ bool CheckRequestAcceptsCompression(HttpContext context);`
`26`	`33`	`}`
`27`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,7 @@ public class ResponseCompressionProvider : IResponseCompressionProvider`
`16`	`16`	`{`
`17`	`17`	`private readonly ICompressionProvider[] _providers;`
`18`	`18`	`private readonly HashSet<string> _mimeTypes;`
	`19`	`+ private readonly bool _enableForHttps;`
`19`	`20`
`20`	`21`	`/// <summary>`
`21`	`22`	`/// If no compression providers are specified then GZip is used by default.`
`@@ -54,6 +55,8 @@ public ResponseCompressionProvider(IServiceProvider services, IOptions<ResponseC`
`54`	`55`	`mimeTypes = ResponseCompressionDefaults.MimeTypes;`
`55`	`56`	`}`
`56`	`57`	`_mimeTypes = new HashSet<string>(mimeTypes, StringComparer.OrdinalIgnoreCase);`
	`58`	`+`
	`59`	`+ _enableForHttps = options.Value.EnableForHttps;`
`57`	`60`	`}`
`58`	`61`
`59`	`62`	`/// <inheritdoc />`
`@@ -103,6 +106,11 @@ public virtual ICompressionProvider GetCompressionProvider(HttpContext context)`
`103`	`106`	`/// <inheritdoc />`
`104`	`107`	`public virtual bool ShouldCompressResponse(HttpContext context)`
`105`	`108`	`{`
	`109`	`+ if (context.Response.Headers.ContainsKey(HeaderNames.ContentRange))`
	`110`	`+ {`
	`111`	`+ return false;`
	`112`	`+ }`
	`113`	`+`
`106`	`114`	`var mimeType = context.Response.ContentType;`
`107`	`115`
`108`	`116`	`if (string.IsNullOrEmpty(mimeType))`
`@@ -121,5 +129,15 @@ public virtual bool ShouldCompressResponse(HttpContext context)`
`121`	`129`	`// TODO PERF: StringSegments?`
`122`	`130`	`return _mimeTypes.Contains(mimeType);`
`123`	`131`	`}`
	`132`	`+`
	`133`	`+ /// <inheritdoc />`
	`134`	`+ public bool CheckRequestAcceptsCompression(HttpContext context)`
	`135`	`+ {`
	`136`	`+ if (context.Request.IsHttps && !_enableForHttps)`
	`137`	`+ {`
	`138`	`+ return false;`
	`139`	`+ }`
	`140`	`+ return !string.IsNullOrEmpty(context.Request.Headers[HeaderNames.AcceptEncoding]);`
	`141`	`+ }`
`124`	`142`	`}`
`125`	`143`	`}`