Minor clean up

Author: Stephane Landelle

api/src/main/java/org/asynchttpclient/HttpResponseBodyPart.java

@@ -33,23 +33,23 @@ public HttpResponseBodyPart(URI uri, AsyncHttpProvider provider) {
     /**
      * Return length of this part in bytes.
      * 
-     * @since 1.8.0
+     * @since 2.0.0
      */
-    abstract public int length();
+    public abstract int length();
 
     /**
      * Return the response body's part bytes received.
      *
      * @return the response body's part bytes received.
      */
-    abstract public byte[] getBodyPartBytes();
+    public abstract byte[] getBodyPartBytes();
 
     /**
      * Method for accessing contents of this part via stream.
      * 
-     * @since 1.8.0
+     * @since 2.0.0
      */
-    abstract public InputStream readBodyPartBytes();
+    public abstract InputStream readBodyPartBytes();
 
     /**
      * Write the available bytes to the {@link java.io.OutputStream}
@@ -58,35 +58,35 @@ public HttpResponseBodyPart(URI uri, AsyncHttpProvider provider) {
      * @return The number of bytes written
      * @throws IOException
      */
-    abstract public int writeTo(OutputStream outputStream) throws IOException;
+    public abstract int writeTo(OutputStream outputStream) throws IOException;
 
     /**
      * Return a {@link ByteBuffer} that wraps the actual bytes read from the response's chunk. The {@link ByteBuffer}
      * capacity is equal to the number of bytes available.
      *
      * @return {@link ByteBuffer}
      */
-    abstract public ByteBuffer getBodyByteBuffer();
+    public abstract ByteBuffer getBodyByteBuffer();
 
     /**
      * Return true if this is the last part.
      *
      * @return true if this is the last part.
      */
-    abstract public boolean isLast();
+    public abstract boolean isLast();
 
     /**
      * Close the underlying connection once the processing has completed. Invoking that method means the
      * underlying TCP connection will be closed as soon as the processing of the response is completed. That
      * means the underlying connection will never get pooled.
      */
-    abstract public void markUnderlyingConnectionAsClosed();
+    public abstract void markUnderlyingConnectionAsClosed();
 
     /**
      * Return true of the underlying connection will be closed once the response has been fully processed.
      *
      * @return true of the underlying connection will be closed once the response has been fully processed.
      */
-    abstract public boolean closeUnderlyingConnection();
+    public abstract boolean closeUnderlyingConnection();
 
 }

providers/netty4/src/main/java/org/asynchttpclient/providers/netty4/Channels.java

@@ -241,7 +241,7 @@ public void close() {
             }
         }
         openChannels.close();
-        if (this.allowReleaseEventLoopGroup) {
+        if (allowReleaseEventLoopGroup) {
             eventLoopGroup.shutdownGracefully();
         }
     }

providers/netty4/src/main/java/org/asynchttpclient/providers/netty4/NettyChannelHandler.java

@@ -2,13 +2,11 @@
 
 import static io.netty.handler.codec.http.HttpResponseStatus.*;
 import static org.asynchttpclient.providers.netty4.util.HttpUtil.*;
-import io.netty.buffer.Unpooled;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandler.Sharable;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelInboundHandlerAdapter;
 import io.netty.handler.codec.PrematureChannelClosureException;
-import io.netty.handler.codec.http.DefaultHttpContent;
 import io.netty.handler.codec.http.HttpClientCodec;
 import io.netty.handler.codec.http.HttpContent;
 import io.netty.handler.codec.http.HttpHeaders;
@@ -673,7 +671,7 @@ public void call() throws Exception {
 
                     if (!interrupt && chunk.content().readableBytes() > 0) {
                         // FIXME why
-                        interrupt = updateBodyAndInterrupt(future, handler, new ResponseBodyPart(future.getURI(), chunk));
+                        interrupt = updateBodyAndInterrupt(future, handler, new ResponseBodyPart(future.getURI(), chunk.content(), last));
                     }
 
                     if (interrupt || last) {
@@ -801,8 +799,7 @@ public void handle(ChannelHandlerContext ctx, NettyResponseFuture future, Object
                 }
 
                 if (frame.content() != null && frame.content().readableBytes() > 0) {
-                    HttpContent webSocketChunk = new DefaultHttpContent(Unpooled.wrappedBuffer(frame.content()));
-                    ResponseBodyPart rp = new ResponseBodyPart(future.getURI(), webSocketChunk);
+                    ResponseBodyPart rp = new ResponseBodyPart(future.getURI(), frame.content(), frame.isFinalFragment());
                     h.onBodyPartReceived(rp);
 
                     NettyWebSocket webSocket = NettyWebSocket.class.cast(h.onCompleted());

providers/netty4/src/main/java/org/asynchttpclient/providers/netty4/ResponseBodyPart.java

@@ -15,8 +15,7 @@
  */
 package org.asynchttpclient.providers.netty4;
 
-import io.netty.handler.codec.http.HttpContent;
-import io.netty.handler.codec.http.LastHttpContent;
+import io.netty.buffer.ByteBuf;
 
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
@@ -34,14 +33,14 @@
 public class ResponseBodyPart extends HttpResponseBodyPart {
 
     private final byte[] bytes;
-    private final boolean isLast;
+    private final boolean last;
     private boolean closeConnection = false;
 
     // FIXME unused AsyncHttpProvider provider
-    public ResponseBodyPart(URI uri, HttpContent chunk) {
+    public ResponseBodyPart(URI uri, ByteBuf buf, boolean last) {
         super(uri, null);
-        bytes = ByteBufUtil.byteBuf2bytes(chunk.content());
-        isLast = chunk instanceof LastHttpContent;
+        bytes = ByteBufUtil.byteBuf2bytes(buf);
+        this.last = last;
     }
 
     /**
@@ -80,7 +79,7 @@ public ByteBuffer getBodyByteBuffer() {
      */
     @Override
     public boolean isLast() {
-        return isLast;
+        return last;
     }
 
     /**