diff --git a/lib/_http_incoming.js b/lib/_http_incoming.js
index 696fcc3b4ce53d..a84cb64bdb8144 100644
--- a/lib/_http_incoming.js
+++ b/lib/_http_incoming.js
@@ -38,13 +38,6 @@ function readStop(socket) {
 function IncomingMessage(socket) {
   Stream.Readable.call(this);
 
-  // Set this to `true` so that stream.Readable won't attempt to read more
-  // data on `IncomingMessage#push` (see `maybeReadMore` in
-  // `_stream_readable.js`). This is important for proper tracking of
-  // `IncomingMessage#_consuming` which is used to dump requests that users
-  // haven't attempted to read.
-  this._readableState.readingMore = true;
-
   this.socket = socket;
   this.connection = socket;
 
@@ -70,9 +63,6 @@ function IncomingMessage(socket) {
   this.statusMessage = null;
   this.client = socket;
 
-  // flag for backwards compatibility grossness.
-  this._consuming = false;
-
   // flag for when we decide that this message cannot possibly be
   // read by the user, so there's no point continuing to handle it.
   this._dumped = false;
@@ -88,15 +78,6 @@ IncomingMessage.prototype.setTimeout = function setTimeout(msecs, callback) {
 };
 
 
-IncomingMessage.prototype.read = function read(n) {
-  if (!this._consuming)
-    this._readableState.readingMore = false;
-  this._consuming = true;
-  this.read = Stream.Readable.prototype.read;
-  return this.read(n);
-};
-
-
 IncomingMessage.prototype._read = function _read(n) {
   // We actually do almost nothing here, because the parserOnBody
   // function fills up our internal buffer directly.  However, we
diff --git a/test/parallel/test-http-dump-req-when-res-ends.js b/test/parallel/test-http-dump-req-when-res-ends.js
new file mode 100644
index 00000000000000..fe63fac1943b77
--- /dev/null
+++ b/test/parallel/test-http-dump-req-when-res-ends.js
@@ -0,0 +1,60 @@
+'use strict'
+
+const common = require('../common');
+const http = require('http');
+const fs = require('fs');
+
+const server = http.createServer(function(req, res) {
+  // this checks if the request gets dumped
+  req.on('resume', common.mustCall(function() {
+    console.log('resume called');
+
+    req.on('data', common.mustCallAtLeast(function(d) {
+      console.log('data', d)
+    }, 1));
+  }));
+
+  // end is not called as we are just exhausting
+  // the in-memory buffer
+  req.on('end', common.mustNotCall);
+
+  // this 'data' handler will be removed when dumped
+  req.on('data', common.mustNotCall);
+
+  // start sending the response
+  res.flushHeaders();
+
+  setTimeout(function () {
+    res.end('hello world');
+  }, common.platformTimeout(100));
+});
+
+server.listen(0, function() {
+  const req = http.request({
+    method: 'POST',
+    port: server.address().port
+  })
+
+  // Send the http request without waiting
+  // for the body
+  req.flushHeaders();
+
+  req.on('response', common.mustCall(function (res) {
+    // pipe the body as soon as we get the headers of the
+    // response back
+    fs.createReadStream(__filename).pipe(req);
+
+    res.setEncoding('utf8');
+
+    let data = ''
+
+    res.on('data', function(d) {
+      data += d;
+    });
+
+    // wait for the response
+    res.on('end', function() {
+      server.close();
+    });
+  }));
+});