fixed http client write buffer failed.

Author: wang007

vertx-core/src/main/java/io/vertx/core/http/impl/HttpClientRequestImpl.java

@@ -360,13 +360,13 @@ public Future<Void> writeCustomFrame(int type, int flags, Buffer payload) {
     synchronized (this) {
       checkEnded();
     }
-    return stream.writeFrame(type, flags, ((BufferInternal)payload).getByteBuf());
+    return stream.writeFrame(type, flags, ((BufferInternal) payload).getByteBuf());
   }
 
   private void handleDrained(Void v) {
     Handler<Void> handler;
     synchronized (this) {
-      handler =  drainHandler;
+      handler = drainHandler;
       if (handler == null || endFuture.isComplete()) {
         return;
       }
@@ -381,7 +381,7 @@ private void handleNextRequest(HttpClientRequest next, Promise<HttpClientRespons
     next.pushHandler(pushHandler());
     next.setFollowRedirects(true);
     next.setMaxRedirects(maxRedirects);
-    ((HttpClientRequestImpl)next).numberOfRedirections = numberOfRedirections + 1;
+    ((HttpClientRequestImpl) next).numberOfRedirections = numberOfRedirections + 1;
     endFuture.onComplete(ar -> {
       if (ar.succeeded()) {
         if (timeoutMs > 0) {
@@ -457,7 +457,7 @@ public Future<Void> end(String chunk, String enc) {
 
   @Override
   public Future<Void> end(Buffer chunk) {
-    return write(((BufferInternal)chunk).getByteBuf(), true);
+    return write(((BufferInternal) chunk).getByteBuf(), true);
   }
 
   @Override
@@ -467,7 +467,7 @@ public Future<Void> end() {
 
   @Override
   public Future<Void> write(Buffer chunk) {
-    ByteBuf buf = ((BufferInternal)chunk).getByteBuf();
+    ByteBuf buf = ((BufferInternal) chunk).getByteBuf();
     return write(buf, false);
   }
 
@@ -482,16 +482,22 @@ public Future<Void> write(String chunk, String enc) {
     return write(BufferInternal.buffer(chunk, enc).getByteBuf(), false);
   }
 
-  private boolean requiresContentLength() {
+  private boolean requiresContentLength(boolean writeHead) {
+    if (writeHead) {
+      return !chunked && (headers == null || !headers.contains(CONTENT_LENGTH)) && !isConnect;
+    }
+    if (version() == HttpVersion.HTTP_2) {
+      return false;
+    }
     return !chunked && (headers == null || !headers.contains(CONTENT_LENGTH)) && !isConnect;
   }
 
   private Future<Void> write(ByteBuf buff, boolean end) {
     if (end) {
-      if (buff != null && requiresContentLength()) {
+      if (buff != null && requiresContentLength(true)) {
         headers().set(CONTENT_LENGTH, HttpUtils.positiveLongToString(buff.readableBytes()));
       }
-    } else if (requiresContentLength()) {
+    } else if (requiresContentLength(false)) {
       throw new IllegalStateException("You must set the Content-Length header to be the total size of the message "
         + "body BEFORE sending any data if you are not using HTTP chunked encoding.");
     }

vertx-core/src/test/java/io/vertx/tests/http/Http2ClientTest.java

@@ -2330,4 +2330,52 @@ public void testClearTestDirectServerCloseBeforeSettingsRead() {
     }));
     await();
   }
+
+  @Test
+  public void testWriteChunked() throws Exception {
+    String p1 = "12345";
+    String p2 = "56789";
+    server.requestHandler(req -> {
+      Buffer buffer = Buffer.buffer();
+      AtomicInteger handleChunkCount = new AtomicInteger();
+      req.handler(buff -> {
+        buffer.appendBuffer(buff);
+        handleChunkCount.incrementAndGet();
+      });
+      req.endHandler(v -> {
+        assertEquals(handleChunkCount.get(), 2);
+        assertEquals(buffer.toString(), p1 + p2);
+
+        HttpServerResponse response = req.response();
+        response.setStatusCode(200);
+        response
+          .write(p2)
+          .flatMap(v0 -> response.end(p1));
+      });
+    });
+    startServer();
+
+    client.request(requestOptions).onComplete(onSuccess(req -> {
+      req.write(p1)
+        .flatMap(v -> req.end(p2));
+
+      AtomicInteger handleChunkCount = new AtomicInteger();
+      Buffer buffer = Buffer.buffer();
+      req.response().onComplete(onSuccess(response -> {
+        response.handler(buf -> {
+          buffer.appendBuffer(buf);
+          handleChunkCount.incrementAndGet();
+        });
+
+        response.endHandler(v -> {
+          assertEquals(handleChunkCount.get(), 2);
+          assertEquals(buffer.toString(), p2 + p1);
+          complete();
+        });
+      }));
+    }));
+
+    await();
+  }
+
 }