inspector: handle string chunks in network http

lib/internal/inspector/network_http.js

@@ -18,6 +18,7 @@ const {
   sniffMimeType,
 } = require('internal/inspector/network');
 const { Network } = require('inspector');
+const { Buffer } = require('buffer');
 const EventEmitter = require('events');
 const { kEmptyObject } = require('internal/util');
 
@@ -138,6 +139,9 @@ function onClientResponseFinish({ request, response }) {
 
   // Unlike response.on('data', ...), this does not put the stream into flowing mode.
   EventEmitter.prototype.on.call(response, 'data', (chunk) => {
+    if (typeof chunk === 'string') {
+      chunk = Buffer.from(chunk, response.readableEncoding);
+    }
     Network.dataReceived({
       requestId: request[kInspectorRequestId],
       timestamp: getMonotonicTime(),

lib/internal/inspector/network_http2.js

@@ -213,6 +213,9 @@ function onClientStreamFinish({ stream, headers }) {
 
   // Unlike stream.on('data', ...), this does not put the stream into flowing mode.
   EventEmitter.prototype.on.call(stream, 'data', (chunk) => {
+    if (typeof chunk === 'string') {
+      chunk = Buffer.from(chunk, stream.readableEncoding);
+    }
     /**
      * When a chunk of the response body has been received, cache it until `getResponseBody` request
      * https://chromedevtools.github.io/devtools-protocol/1-3/Network/#method-getResponseBody or

test/parallel/test-inspector-network-http.js

@@ -250,6 +250,36 @@ async function testHttpGet() {
   await assertResponseBody(responseReceived, '\nhello world\n');
 }
 
+async function testHttpGetWithSetEncoding() {
+  const url = `http://127.0.0.1:${httpServer.address().port}/hello-world`;
+  const {
+    requestWillBeSentFuture,
+    responseReceivedFuture,
+    loadingFinishedFuture,
+  } = createRequestTracker(url, getDefaultResponseExpect(url));
+
+  http.get({
+    host: '127.0.0.1',
+    port: httpServer.address().port,
+    path: '/hello-world',
+    headers: requestHeaders
+  }, common.mustCall((response) => {
+    response.setEncoding('utf8');
+    let body = '';
+    response.on('data', (chunk) => {
+      body += chunk;
+    });
+    response.on('end', common.mustCall(() => {
+      assert.strictEqual(body, '\nhello world\n');
+    }));
+  }));
+
+  await requestWillBeSentFuture;
+  const responseReceived = await responseReceivedFuture;
+  await loadingFinishedFuture;
+  await assertResponseBody(responseReceived, '\nhello world\n');
+}
+
 async function testHttpGetWithAbsoluteUrlPath() {
   const url = `http://127.0.0.1:${httpServer.address().port}/hello-world`;
   const {
@@ -383,6 +413,8 @@ async function testHttpsError() {
 const testNetworkInspection = async () => {
   await testHttpGet();
   session.removeAllListeners();
+  await testHttpGetWithSetEncoding();
+  session.removeAllListeners();
   await testHttpGetWithAbsoluteUrlPath();
   session.removeAllListeners();
   await testHttpPostWithAbsoluteUrlPath();

test/parallel/test-inspector-network-http2.js

@@ -87,6 +87,10 @@ const handleStream = common.mustCallAtLeast((stream, headers) => {
         }, kTimeout);
       }));
       break;
+    case '/set-encoding':
+      stream.respond(responseHeaders);
+      stream.end(serverResponse);
+      break;
     case '/trigger-error':
       stream.close(http2.constants.NGHTTP2_STREAM_CLOSED);
       stream.on('error', common.expectsError({
@@ -283,6 +287,38 @@ async function testHttp2(secure = false) {
   assert.ok(delta > kDelta);
 }
 
+async function testHttp2WithSetEncoding() {
+  const origin = `http://localhost:${http2Server.address().port}`;
+
+  const responseReceived = once(session, 'Network.responseReceived');
+  const loadingFinished = once(session, 'Network.loadingFinished');
+  session.on('Network.loadingFailed', common.mustNotCall());
+
+  const client = http2.connect(origin);
+  const request = client.request({
+    [http2.constants.HTTP2_HEADER_PATH]: '/set-encoding',
+  });
+  request.setEncoding('hex');
+  let body = '';
+  request.on('data', (chunk) => {
+    body += chunk;
+  });
+  request.on('end', common.mustCall(() => {
+    assert.strictEqual(body, Buffer.from(serverResponse).toString('hex'));
+    client.close();
+  }));
+  request.end();
+
+  const [ response ] = await responseReceived;
+  await loadingFinished;
+
+  const responseBody = await session.post('Network.getResponseBody', {
+    requestId: response.params.requestId,
+  });
+  assert.strictEqual(responseBody.base64Encoded, false);
+  assert.strictEqual(responseBody.body, serverResponse);
+}
+
 async function testHttp2Error(secure = false) {
   const port = (secure ? http2SecureServer : http2Server).address().port;
   const origin = (secure ? 'https' : 'http') + `://localhost:${port}`;
@@ -321,6 +357,8 @@ const testNetworkInspection = async () => {
   session.removeAllListeners();
   await testHttp2(true);
   session.removeAllListeners();
+  await testHttp2WithSetEncoding();
+  session.removeAllListeners();
   await testHttp2Error();
   session.removeAllListeners();
   await testHttp2Error(true);