httpReadData(message, response, cb) {
    let payload = null;
    response.aborted = false;

    response.onData((data, isLast) => {
      const chunk = Buffer.from(data);

      payload = payload
        ? Buffer.concat([payload, chunk])
        : Buffer.concat([chunk]);

      /*
       * The content-length header can be bypassed and
       * is not reliable enough. We have to enforce the HTTP
       * max size limit while reading chunks too
       */
      if (payload.byteLength > this.maxRequestSize) {
        cb(HTTP_REQUEST_TOO_LARGE_ERROR);
        return;
      }

      if (!isLast) {
        return;
      }

      if (payload.byteLength === 0) {
        cb();
        return;
      }

      let resolve;
      let promise = new Promise((res) => (resolve = res));

      this.httpUncompress(message, payload, async (err, inflated) => {
        if (err) {
          cb(err);
          resolve();
          return;
        }

        const { payload: newPayload } = await global.kuzzle.pipe(
          "protocol:http:beforeParsingPayload",
          { message, payload: inflated },
        );
        await this.httpParseContent(message, newPayload, cb);
        resolve();
      });

      return promise;
    });

    // Beware: the "response" object might be invalidated at any point of time,
    // whenever the connection gets closed by the client for instance
    response.onAborted(() => {
      response.aborted = true;
    });
  }
Read an HTTP payload data

@param  {HttpMessage} message
@param  {uWS.HttpResponse} response
@param  {Function} cb