diff --git a/scrapy/downloadermiddlewares/httpcompression.py b/scrapy/downloadermiddlewares/httpcompression.py
index 4e7feeeafac..b6bbfc1dfcd 100644
--- a/scrapy/downloadermiddlewares/httpcompression.py
+++ b/scrapy/downloadermiddlewares/httpcompression.py
@@ -3,7 +3,7 @@
 import zlib
 
 from scrapy.exceptions import NotConfigured
-from scrapy.http import Response, TextResponse
+from scrapy.http import TextResponse
 from scrapy.responsetypes import responsetypes
 from scrapy.utils.deprecate import ScrapyDeprecationWarning
 from scrapy.utils.gz import gunzip
@@ -27,24 +27,43 @@
 class HttpCompressionMiddleware:
     """This middleware allows compressed (gzip, deflate) traffic to be
     sent/received from web sites"""
-    def __init__(self, stats=None):
+    def __init__(self, stats=None, settings=None):
         self.stats = stats
+        if not stats:
+            warnings.warn(
+                "HttpCompressionMiddleware now accepts a 'stats' parameter which should be specified.",
+                ScrapyDeprecationWarning,
+            )
+        if settings:
+            self.keep_encoding_header = settings.getbool('COMPRESSION_KEEP_ENCODING_HEADER')
+            if not self.keep_encoding_header:
+                warnings.warn(
+                    "Setting COMPRESSION_KEEP_ENCODING_HEADER=False is deprecated",
+                    ScrapyDeprecationWarning,
+                )
+        else:
+            self.keep_encoding_header = False
+            warnings.warn(
+                "HttpCompressionMiddleware now accepts a 'settings' parameter which should be specified.",
+                ScrapyDeprecationWarning,
+            )
 
     @classmethod
     def from_crawler(cls, crawler):
         if not crawler.settings.getbool('COMPRESSION_ENABLED'):
             raise NotConfigured
         try:
-            return cls(stats=crawler.stats)
+            return cls(stats=crawler.stats, settings=crawler.settings)
         except TypeError:
             warnings.warn(
                 "HttpCompressionMiddleware subclasses must either modify "
-                "their '__init__' method to support a 'stats' parameter or "
+                "their '__init__' method to support 'stats' and 'settings' parameters or "
                 "reimplement the 'from_crawler' method.",
                 ScrapyDeprecationWarning,
             )
             result = cls()
             result.stats = crawler.stats
+            result.keep_encoding_header = False
             return result
 
     def process_request(self, request, spider):
@@ -52,28 +71,34 @@ def process_request(self, request, spider):
                                    b", ".join(ACCEPTED_ENCODINGS))
 
     def process_response(self, request, response, spider):
-
         if request.method == 'HEAD':
             return response
-        if isinstance(response, Response):
-            content_encoding = response.headers.getlist('Content-Encoding')
-            if content_encoding:
-                encoding = content_encoding.pop()
-                decoded_body = self._decode(response.body, encoding.lower())
-                if self.stats:
-                    self.stats.inc_value('httpcompression/response_bytes', len(decoded_body), spider=spider)
-                    self.stats.inc_value('httpcompression/response_count', spider=spider)
-                respcls = responsetypes.from_args(
-                    headers=response.headers, url=response.url, body=decoded_body
-                )
-                kwargs = dict(cls=respcls, body=decoded_body)
-                if issubclass(respcls, TextResponse):
-                    # force recalculating the encoding until we make sure the
-                    # responsetypes guessing is reliable
-                    kwargs['encoding'] = None
-                response = response.replace(**kwargs)
-                if not content_encoding:
-                    del response.headers['Content-Encoding']
+
+        if b'decoded' in response.flags:
+            return response
+
+        content_encoding = response.headers.getlist('Content-Encoding')
+        if not content_encoding:
+            return response
+
+        encoding = content_encoding[0]
+        decoded_body = self._decode(response.body, encoding.lower())
+        if self.stats:
+            self.stats.inc_value('httpcompression/response_bytes', len(decoded_body), spider=spider)
+            self.stats.inc_value('httpcompression/response_count', spider=spider)
+        respcls = responsetypes.from_args(
+            headers=response.headers, url=response.url, body=decoded_body
+        )
+        kwargs = dict(cls=respcls, body=decoded_body)
+        if issubclass(respcls, TextResponse):
+            # force recalculating the encoding until we make sure the
+            # responsetypes guessing is reliable
+            kwargs['encoding'] = None
+
+        kwargs['flags'] = response.flags + [b'decoded']
+        response = response.replace(**kwargs)
+        if not self.keep_encoding_header:
+            del response.headers['Content-Encoding']
 
         return response
 
diff --git a/scrapy/settings/default_settings.py b/scrapy/settings/default_settings.py
index 8389a70cb4b..02dd20b2190 100644
--- a/scrapy/settings/default_settings.py
+++ b/scrapy/settings/default_settings.py
@@ -37,6 +37,7 @@
 COMMANDS_MODULE = ''
 
 COMPRESSION_ENABLED = True
+COMPRESSION_KEEP_ENCODING_HEADER = True
 
 CONCURRENT_ITEMS = 100
 
diff --git a/scrapy/templates/project/module/settings.py.tmpl b/scrapy/templates/project/module/settings.py.tmpl
index a414b5fde5b..1b4a9d7516d 100644
--- a/scrapy/templates/project/module/settings.py.tmpl
+++ b/scrapy/templates/project/module/settings.py.tmpl
@@ -86,3 +86,6 @@ ROBOTSTXT_OBEY = True
 #HTTPCACHE_DIR = 'httpcache'
 #HTTPCACHE_IGNORE_HTTP_CODES = []
 #HTTPCACHE_STORAGE = 'scrapy.extensions.httpcache.FilesystemCacheStorage'
+
+# Keep the original Content-Encoding header
+COMPRESSION_KEEP_ENCODING_HEADER = True
diff --git a/tests/test_downloadermiddleware_httpcompression.py b/tests/test_downloadermiddleware_httpcompression.py
index 40e9f3a9644..6c7b6ae33f1 100644
--- a/tests/test_downloadermiddleware_httpcompression.py
+++ b/tests/test_downloadermiddleware_httpcompression.py
@@ -4,6 +4,7 @@
 from unittest import TestCase, SkipTest
 from warnings import catch_warnings
 
+from scrapy.settings import Settings
 from scrapy.spiders import Spider
 from scrapy.http import Response, Request, HtmlResponse
 from scrapy.downloadermiddlewares.httpcompression import HttpCompressionMiddleware, ACCEPTED_ENCODINGS
@@ -14,7 +15,6 @@
 from tests import tests_datadir
 from w3lib.encoding import resolve_encoding
 
-
 SAMPLEDIR = join(tests_datadir, 'compressed')
 
 FORMAT = {
@@ -102,23 +102,25 @@ def test_process_response_gzip(self):
 
         self.assertEqual(response.headers['Content-Encoding'], b'gzip')
         newresponse = self.mw.process_response(request, response, self.spider)
-        assert newresponse is not response
-        assert newresponse.body.startswith(b'<!DOCTYPE')
-        assert 'Content-Encoding' not in newresponse.headers
+        self.assertNotEqual(newresponse, response)
+        self.assertTrue(newresponse.body.startswith(b'<!DOCTYPE'))
+        self.assertIn('Content-Encoding', newresponse.headers)
+        self.assertIn(b'gzip', newresponse.headers['Content-Encoding'])
         self.assertStatsEqual('httpcompression/response_count', 1)
         self.assertStatsEqual('httpcompression/response_bytes', 74837)
 
     def test_process_response_gzip_no_stats(self):
-        mw = HttpCompressionMiddleware()
+        mw = HttpCompressionMiddleware(settings=Settings({'COMPRESSION_KEEP_ENCODING_HEADER': True}))
         response = self._getresponse('gzip')
         request = response.request
 
         self.assertEqual(response.headers['Content-Encoding'], b'gzip')
         newresponse = mw.process_response(request, response, self.spider)
         self.assertEqual(mw.stats, None)
-        assert newresponse is not response
-        assert newresponse.body.startswith(b'<!DOCTYPE')
-        assert 'Content-Encoding' not in newresponse.headers
+        self.assertNotEqual(newresponse, response)
+        self.assertTrue(newresponse.body.startswith(b'<!DOCTYPE'))
+        self.assertIn('Content-Encoding', newresponse.headers)
+        self.assertIn(b'gzip', newresponse.headers['Content-Encoding'])
 
     def test_process_response_br(self):
         try:
@@ -129,9 +131,10 @@ def test_process_response_br(self):
         request = response.request
         self.assertEqual(response.headers['Content-Encoding'], b'br')
         newresponse = self.mw.process_response(request, response, self.spider)
-        assert newresponse is not response
-        assert newresponse.body.startswith(b"<!DOCTYPE")
-        assert 'Content-Encoding' not in newresponse.headers
+        self.assertNotEqual(newresponse, response)
+        self.assertTrue(newresponse.body.startswith(b'<!DOCTYPE'))
+        self.assertIn('Content-Encoding', newresponse.headers)
+        self.assertEqual(b'br', newresponse.headers['Content-Encoding'])
         self.assertStatsEqual('httpcompression/response_count', 1)
         self.assertStatsEqual('httpcompression/response_bytes', 74837)
 
@@ -151,10 +154,11 @@ def test_process_response_zstd(self):
             if raw_content is None:
                 raw_content = newresponse.body
             else:
-                assert raw_content == newresponse.body
-            assert newresponse is not response
-            assert newresponse.body.startswith(b"<!DOCTYPE")
-            assert 'Content-Encoding' not in newresponse.headers
+                self.assertEqual(raw_content, newresponse.body)
+            self.assertNotEqual(newresponse, response)
+            self.assertTrue(newresponse.body.startswith(b'<!DOCTYPE'))
+            self.assertIn('Content-Encoding', newresponse.headers)
+            self.assertEqual(b'zstd', newresponse.headers['Content-Encoding'])
 
     def test_process_response_rawdeflate(self):
         response = self._getresponse('rawdeflate')
@@ -162,11 +166,13 @@ def test_process_response_rawdeflate(self):
 
         self.assertEqual(response.headers['Content-Encoding'], b'deflate')
         newresponse = self.mw.process_response(request, response, self.spider)
-        assert newresponse is not response
-        assert newresponse.body.startswith(b'<!DOCTYPE')
-        assert 'Content-Encoding' not in newresponse.headers
+        self.assertNotEqual(newresponse, response)
+        self.assertTrue(newresponse.body.startswith(b'<!DOCTYPE'))
+        self.assertIn('Content-Encoding', newresponse.headers)
+        self.assertIn(b'deflate', newresponse.headers['Content-Encoding'])
         self.assertStatsEqual('httpcompression/response_count', 1)
         self.assertStatsEqual('httpcompression/response_bytes', 74840)
+        self.assertIn(b'decoded', newresponse.flags)
 
     def test_process_response_zlibdelate(self):
         response = self._getresponse('zlibdeflate')
@@ -174,20 +180,23 @@ def test_process_response_zlibdelate(self):
 
         self.assertEqual(response.headers['Content-Encoding'], b'deflate')
         newresponse = self.mw.process_response(request, response, self.spider)
-        assert newresponse is not response
-        assert newresponse.body.startswith(b'<!DOCTYPE')
-        assert 'Content-Encoding' not in newresponse.headers
+        self.assertNotEqual(newresponse, response)
+        self.assertTrue(newresponse.body.startswith(b'<!DOCTYPE'))
+        self.assertIn('Content-Encoding', newresponse.headers)
+        self.assertIn(b'deflate', newresponse.headers['Content-Encoding'])
         self.assertStatsEqual('httpcompression/response_count', 1)
         self.assertStatsEqual('httpcompression/response_bytes', 74840)
+        self.assertIn(b'decoded', newresponse.flags)
 
     def test_process_response_plain(self):
         response = Response('http://scrapytest.org', body=b'<!DOCTYPE...')
         request = Request('http://scrapytest.org')
 
-        assert not response.headers.get('Content-Encoding')
+        self.assertTrue(not response.headers.get('Content-Encoding'))
         newresponse = self.mw.process_response(request, response, self.spider)
-        assert newresponse is response
-        assert newresponse.body.startswith(b'<!DOCTYPE')
+        self.assertEqual(newresponse, response)
+        self.assertTrue(newresponse.body.startswith(b'<!DOCTYPE'))
+        self.assertNotIn('Content-Encoding', newresponse.headers)
         self.assertStatsEqual('httpcompression/response_count', None)
         self.assertStatsEqual('httpcompression/response_bytes', None)
 
@@ -196,8 +205,9 @@ def test_multipleencodings(self):
         response.headers['Content-Encoding'] = ['uuencode', 'gzip']
         request = response.request
         newresponse = self.mw.process_response(request, response, self.spider)
-        assert newresponse is not response
-        self.assertEqual(newresponse.headers.getlist('Content-Encoding'), [b'uuencode'])
+        self.assertNotEqual(newresponse, response)
+        self.assertEqual(newresponse.headers.getlist('Content-Encoding'), [b'uuencode', b'gzip'])
+        self.assertIn(b'decoded', newresponse.flags)
 
     def test_process_response_encoding_inside_body(self):
         headers = {
@@ -214,11 +224,14 @@ def test_process_response_encoding_inside_body(self):
         request = Request("http://www.example.com/")
 
         newresponse = self.mw.process_response(request, response, self.spider)
-        assert isinstance(newresponse, HtmlResponse)
+        self.assertIsInstance(newresponse, HtmlResponse)
         self.assertEqual(newresponse.body, plainbody)
         self.assertEqual(newresponse.encoding, resolve_encoding('gb2312'))
         self.assertStatsEqual('httpcompression/response_count', 1)
         self.assertStatsEqual('httpcompression/response_bytes', 104)
+        self.assertIn('Content-Encoding', newresponse.headers)
+        self.assertEqual(b'gzip', newresponse.headers['Content-Encoding'])
+        self.assertIn(b'decoded', newresponse.flags)
 
     def test_process_response_force_recalculate_encoding(self):
         headers = {
@@ -235,11 +248,14 @@ def test_process_response_force_recalculate_encoding(self):
         request = Request("http://www.example.com/")
 
         newresponse = self.mw.process_response(request, response, self.spider)
-        assert isinstance(newresponse, HtmlResponse)
+        self.assertIsInstance(newresponse, HtmlResponse)
         self.assertEqual(newresponse.body, plainbody)
         self.assertEqual(newresponse.encoding, resolve_encoding('gb2312'))
+        self.assertIn('Content-Encoding', newresponse.headers)
+        self.assertEqual(b'gzip', newresponse.headers['Content-Encoding'])
         self.assertStatsEqual('httpcompression/response_count', 1)
         self.assertStatsEqual('httpcompression/response_bytes', 104)
+        self.assertIn(b'decoded', newresponse.flags)
 
     def test_process_response_no_content_type_header(self):
         headers = {
@@ -252,11 +268,14 @@ def test_process_response_no_content_type_header(self):
         request = Request("http://www.example.com/index")
 
         newresponse = self.mw.process_response(request, response, self.spider)
-        assert isinstance(newresponse, respcls)
+        self.assertIsInstance(newresponse, respcls)
         self.assertEqual(newresponse.body, plainbody)
         self.assertEqual(newresponse.encoding, resolve_encoding('gb2312'))
+        self.assertIn('Content-Encoding', newresponse.headers)
+        self.assertEqual(b'identity', newresponse.headers['Content-Encoding'])
         self.assertStatsEqual('httpcompression/response_count', 1)
         self.assertStatsEqual('httpcompression/response_bytes', 104)
+        self.assertIn(b'decoded', newresponse.flags)
 
     def test_process_response_gzipped_contenttype(self):
         response = self._getresponse('gzip')
@@ -266,9 +285,11 @@ def test_process_response_gzipped_contenttype(self):
         newresponse = self.mw.process_response(request, response, self.spider)
         self.assertIsNot(newresponse, response)
         self.assertTrue(newresponse.body.startswith(b'<!DOCTYPE'))
-        self.assertNotIn('Content-Encoding', newresponse.headers)
+        self.assertIn('Content-Encoding', newresponse.headers)
+        self.assertEqual(b'gzip', newresponse.headers['Content-Encoding'])
         self.assertStatsEqual('httpcompression/response_count', 1)
         self.assertStatsEqual('httpcompression/response_bytes', 74837)
+        self.assertIn(b'decoded', newresponse.flags)
 
     def test_process_response_gzip_app_octetstream_contenttype(self):
         response = self._getresponse('gzip')
@@ -278,9 +299,11 @@ def test_process_response_gzip_app_octetstream_contenttype(self):
         newresponse = self.mw.process_response(request, response, self.spider)
         self.assertIsNot(newresponse, response)
         self.assertTrue(newresponse.body.startswith(b'<!DOCTYPE'))
-        self.assertNotIn('Content-Encoding', newresponse.headers)
+        self.assertIn('Content-Encoding', newresponse.headers)
+        self.assertEqual(b'gzip', newresponse.headers['Content-Encoding'])
         self.assertStatsEqual('httpcompression/response_count', 1)
         self.assertStatsEqual('httpcompression/response_bytes', 74837)
+        self.assertIn(b'decoded', newresponse.flags)
 
     def test_process_response_gzip_binary_octetstream_contenttype(self):
         response = self._getresponse('x-gzip')
@@ -290,9 +313,11 @@ def test_process_response_gzip_binary_octetstream_contenttype(self):
         newresponse = self.mw.process_response(request, response, self.spider)
         self.assertIsNot(newresponse, response)
         self.assertTrue(newresponse.body.startswith(b'<!DOCTYPE'))
-        self.assertNotIn('Content-Encoding', newresponse.headers)
+        self.assertIn('Content-Encoding', newresponse.headers)
+        self.assertEqual(b'gzip', newresponse.headers['Content-Encoding'])
         self.assertStatsEqual('httpcompression/response_count', 1)
         self.assertStatsEqual('httpcompression/response_bytes', 74837)
+        self.assertIn(b'decoded', newresponse.flags)
 
     def test_process_response_gzipped_gzip_file(self):
         """Test that a gzip Content-Encoded .gz file is gunzipped
@@ -337,6 +362,9 @@ def test_process_response_gzipped_gzip_file(self):
         self.assertEqual(gunzip(newresponse.body), plainbody)
         self.assertStatsEqual('httpcompression/response_count', 1)
         self.assertStatsEqual('httpcompression/response_bytes', 230)
+        self.assertIn('Content-Encoding', newresponse.headers)
+        self.assertEqual(b'gzip', newresponse.headers['Content-Encoding'])
+        self.assertIn(b'decoded', newresponse.flags)
 
     def test_process_response_head_request_no_decode_required(self):
         response = self._getresponse('gzip')
@@ -347,13 +375,48 @@ def test_process_response_head_request_no_decode_required(self):
         newresponse = self.mw.process_response(request, response, self.spider)
         self.assertIs(newresponse, response)
         self.assertEqual(response.body, b'')
+        self.assertIn('Content-Encoding', newresponse.headers)
+        self.assertEqual(b'gzip', newresponse.headers['Content-Encoding'])
         self.assertStatsEqual('httpcompression/response_count', None)
         self.assertStatsEqual('httpcompression/response_bytes', None)
 
+    def test_process_response_keeps_content_encoding_header(self):
+        settings = {'COMPRESSION_ENABLED': True,
+                    'COMPRESSION_KEEP_ENCODING_HEADER': True}
+        crawler = get_crawler(Spider, settings)
+        spider = crawler._create_spider('example.com')
+        mw = HttpCompressionMiddleware.from_crawler(crawler)
+        response = self._getresponse('gzip')
+        request = response.request
+
+        self.assertEqual(response.headers['Content-Encoding'], b'gzip')
+        newresponse = mw.process_response(request, response, spider)
+        self.assertIsNot(newresponse, response)
+        self.assertTrue(newresponse.body.startswith(b'<!DOCTYPE'))
+        self.assertIn('Content-Encoding', newresponse.headers)
+        self.assertIn(b'gzip', newresponse.headers['Content-Encoding'])
+        self.assertIn(b'decoded', newresponse.flags)
+
+    def test_process_response_doesnt_keep_content_encoding_header(self):
+        settings = {'COMPRESSION_ENABLED': True,
+                    'COMPRESSION_KEEP_ENCODING_HEADER': False}
+        crawler = get_crawler(Spider, settings)
+        spider = crawler._create_spider('example.com')
+        mw = HttpCompressionMiddleware.from_crawler(crawler)
+        response = self._getresponse('gzip')
+        request = response.request
+
+        self.assertEqual(response.headers['Content-Encoding'], b'gzip')
+        newresponse = mw.process_response(request, response, spider)
+        self.assertIsNot(newresponse, response)
+        self.assertTrue(newresponse.body.startswith(b'<!DOCTYPE'))
+        self.assertNotIn('Content-Encoding', newresponse.headers)
+        self.assertIn(b'decoded', newresponse.flags)
+
 
 class HttpCompressionSubclassTest(TestCase):
 
-    def test_init_missing_stats(self):
+    def test_from_crawler_missing_args(self):
         class HttpCompressionMiddlewareSubclass(HttpCompressionMiddleware):
 
             def __init__(self):
@@ -369,10 +432,45 @@ def __init__(self):
         self.assertEqual(
             messages,
             (
-                (
-                    "HttpCompressionMiddleware subclasses must either modify "
-                    "their '__init__' method to support a 'stats' parameter "
-                    "or reimplement the 'from_crawler' method."
-                ),
-            )
+                "HttpCompressionMiddleware subclasses must either modify "
+                "their '__init__' method to support 'stats' and 'settings' parameters "
+                "or reimplement the 'from_crawler' method.",
+                "HttpCompressionMiddleware now accepts a 'stats' parameter which should be specified.",
+                "HttpCompressionMiddleware now accepts a 'settings' parameter which should be specified.",
+            ),
+        )
+
+    def test_init_missing_args(self):
+        with catch_warnings(record=True) as caught_warnings:
+            self.assertIsNotNone(HttpCompressionMiddleware(stats=None, settings=None))
+        messages = tuple(
+            str(warning.message) for warning in caught_warnings
+            if warning.category is ScrapyDeprecationWarning
+        )
+
+        self.assertEqual(
+            messages,
+            (
+                "HttpCompressionMiddleware now accepts a 'stats' parameter which should be specified.",
+                "HttpCompressionMiddleware now accepts a 'settings' parameter which should be specified.",
+            ),
+        )
+
+    def test_init_keep_encoding_header_deprecation_warning(self):
+        from scrapy.settings import Settings
+        settings = Settings({'COMPRESSION_KEEP_ENCODING_HEADER': False})
+
+        with catch_warnings(record=True) as caught_warnings:
+            mw = HttpCompressionMiddleware(stats={'foo': 'bar'}, settings=settings)
+            self.assertIsNotNone(mw)
+        messages = tuple(
+            str(warning.message) for warning in caught_warnings
+            if warning.category is ScrapyDeprecationWarning
+        )
+
+        self.assertEqual(
+            messages,
+            (
+                "Setting COMPRESSION_KEEP_ENCODING_HEADER=False is deprecated",
+            ),
         )