Revert "Add PooledSlicedByteBuf and PooledDuplicatedByteBuf"

Motivation:
Currently the "derived" buffer will only ever be recycled if the release call is made on the "derived" object, and the "wrapped" buffer ends up being "fully released" (aka refcount goes to 0). From my experience this is not the common use case and thus the "derived" buffers will not be recycled.

Modifications:
- revert https://github.com/netty/netty/pull/3788

Result:
Less complexity, and less code to create new objects in majority of cases.

buffer/src/main/java/io/netty/buffer/AbstractDerivedByteBuf.java

@@ -47,20 +47,12 @@ public abstract class AbstractDerivedByteBuf extends AbstractByteBuf {
 
     @Override
     public final boolean release() {
-        if (unwrap().release()) {
-            deallocate();
-            return true;
-        }
-        return false;
+        return unwrap().release();
     }
 
     @Override
     public final boolean release(int decrement) {
-        if (unwrap().release(decrement)) {
-            deallocate();
-            return true;
-        }
-        return false;
+        return unwrap().release(decrement);
     }
 
     @Override
@@ -72,9 +64,4 @@ public abstract class AbstractDerivedByteBuf extends AbstractByteBuf {
     public ByteBuffer nioBuffer(int index, int length) {
         return unwrap().nioBuffer(index, length);
     }
-
-    /**
-     * Called when the wrapped {@link ByteBuf} was released due calling of {@link #release()} or {@link #release(int)}.
-     */
-    protected void deallocate() { }
 }

buffer/src/main/java/io/netty/buffer/DuplicatedByteBuf.java

@@ -31,19 +31,11 @@ import java.nio.channels.ScatteringByteChannel;
  */
 public class DuplicatedByteBuf extends AbstractDerivedByteBuf {
 
-    private ByteBuf buffer;
+    private final ByteBuf buffer;
 
     public DuplicatedByteBuf(ByteBuf buffer) {
         super(buffer.maxCapacity());
-        init(buffer);
-    }
 
-    DuplicatedByteBuf(int maxCapacity) {
-        super(maxCapacity);
-    }
-
-    final void init(ByteBuf buffer) {
-        maxCapacity(buffer.maxCapacity());
         if (buffer instanceof DuplicatedByteBuf) {
             this.buffer = ((DuplicatedByteBuf) buffer).buffer;
         } else {
@@ -51,8 +43,6 @@ public class DuplicatedByteBuf extends AbstractDerivedByteBuf {
         }
 
         setIndex(buffer.readerIndex(), buffer.writerIndex());
-        markReaderIndex();
-        markWriterIndex();
     }
 
     @Override

buffer/src/main/java/io/netty/buffer/PooledByteBuf.java

@@ -68,16 +68,6 @@ abstract class PooledByteBuf<T> extends AbstractReferenceCountedByteBuf {
         cache = null;
     }
 
-    @Override
-    public ByteBuf slice(int index, int length) {
-        return PooledSlicedByteBuf.newInstance(this, index, length);
-    }
-
-    @Override
-    public ByteBuf duplicate() {
-        return PooledDuplicatedByteBuf.newInstance(this);
-    }
-
     @Override
     public final int capacity() {
         return length;

buffer/src/main/java/io/netty/buffer/PooledDuplicatedByteBuf.java

@@ -1,56 +0,0 @@
-/*
- * Copyright 2015 The Netty Project
- *
- * The Netty Project licenses this file to you under the Apache License,
- * version 2.0 (the "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at:
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- */
-package io.netty.buffer;
-
-import io.netty.util.Recycler;
-
-final class PooledDuplicatedByteBuf extends DuplicatedByteBuf {
-
-    private static final Recycler<PooledDuplicatedByteBuf> RECYCLER = new Recycler<PooledDuplicatedByteBuf>() {
-        @Override
-        protected PooledDuplicatedByteBuf newObject(Handle handle) {
-            return new PooledDuplicatedByteBuf(handle);
-        }
-    };
-
-    static PooledDuplicatedByteBuf newInstance(ByteBuf buffer) {
-        PooledDuplicatedByteBuf buf = RECYCLER.get();
-        buf.init(buffer);
-        return buf;
-    }
-
-    private final Recycler.Handle recyclerHandle;
-
-    private PooledDuplicatedByteBuf(Recycler.Handle recyclerHandle) {
-        super(0);
-        this.recyclerHandle = recyclerHandle;
-    }
-
-    @Override
-    public ByteBuf slice(int index, int length) {
-        return PooledSlicedByteBuf.newInstance(this, index, length);
-    }
-
-    @Override
-    public ByteBuf duplicate() {
-        return newInstance(this);
-    }
-
-    @Override
-    protected void deallocate() {
-        RECYCLER.recycle(this, recyclerHandle);
-    }
-}

buffer/src/main/java/io/netty/buffer/PooledSlicedByteBuf.java

@@ -1,56 +0,0 @@
-/*
- * Copyright 2015 The Netty Project
- *
- * The Netty Project licenses this file to you under the Apache License,
- * version 2.0 (the "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at:
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- */
-package io.netty.buffer;
-
-import io.netty.util.Recycler;
-
-final class PooledSlicedByteBuf extends SlicedByteBuf {
-
-    private static final Recycler<PooledSlicedByteBuf> RECYCLER = new Recycler<PooledSlicedByteBuf>() {
-        @Override
-        protected PooledSlicedByteBuf newObject(Handle handle) {
-            return new PooledSlicedByteBuf(handle);
-        }
-    };
-
-    static PooledSlicedByteBuf newInstance(ByteBuf buffer, int index, int length) {
-        PooledSlicedByteBuf buf = RECYCLER.get();
-        buf.init(buffer, index, length);
-        return buf;
-    }
-
-    private final Recycler.Handle recyclerHandle;
-
-    private PooledSlicedByteBuf(Recycler.Handle recyclerHandle) {
-        super(0);
-        this.recyclerHandle = recyclerHandle;
-    }
-
-    @Override
-    public ByteBuf slice(int index, int length) {
-        return newInstance(this, index, length);
-    }
-
-    @Override
-    public ByteBuf duplicate() {
-        return PooledDuplicatedByteBuf.newInstance(this);
-    }
-
-    @Override
-    protected void deallocate() {
-        RECYCLER.recycle(this, recyclerHandle);
-    }
-}

buffer/src/main/java/io/netty/buffer/SlicedByteBuf.java

@@ -32,20 +32,12 @@ import java.nio.channels.ScatteringByteChannel;
  */
 public class SlicedByteBuf extends AbstractDerivedByteBuf {
 
-    private ByteBuf buffer;
-    private int adjustment;
-    private int length;
+    private final ByteBuf buffer;
+    private final int adjustment;
+    private final int length;
 
     public SlicedByteBuf(ByteBuf buffer, int index, int length) {
         super(length);
-        init(buffer, index, length);
-    }
-
-    SlicedByteBuf(int length) {
-        super(length);
-    }
-
-    final void init(ByteBuf buffer, int index, int length) {
         if (index < 0 || index > buffer.capacity() - length) {
             throw new IndexOutOfBoundsException(buffer + ".slice(" + index + ", " + length + ')');
         }
@@ -61,9 +53,8 @@ public class SlicedByteBuf extends AbstractDerivedByteBuf {
             adjustment = index;
         }
         this.length = length;
-        maxCapacity(length);
-        setIndex(0, length);
-        discardMarks();
+
+        writerIndex(length);
     }
 
     @Override