[#4017] Implement proper resource leak detection for CompositeByteBuf

Motivation: CompositeByteBuf only implemented simple resource leak detection and how it was implemented was completly different to the way it was for ByteBuf. The other problem was that slice(), duplicate() and others would not return a resource leak enabled buffer. Modifications: - Proper implementation for all level of resource leak detection for CompositeByteBuf Result: Proper resource leak detection for CompositeByteBuf.
2016-01-12 15:06:30 +01:00 · 2016-01-12 15:06:30 +01:00 · cdb70d31ee
parent e969b6917c
commit cdb70d31ee
8 changed files with 2369 additions and 157 deletions
--- a/buffer/src/main/java/io/netty/buffer/AbstractByteBufAllocator.java
+++ b/buffer/src/main/java/io/netty/buffer/AbstractByteBufAllocator.java
@ -26,7 +26,7 @@ import io.netty.util.internal.StringUtil;
 */
 public abstract class AbstractByteBufAllocator implements ByteBufAllocator {
    private static final int DEFAULT_INITIAL_CAPACITY = 256;
-    private static final int DEFAULT_MAX_COMPONENTS = 16;
+    static final int DEFAULT_MAX_COMPONENTS = 16;

    protected static ByteBuf toLeakAwareBuffer(ByteBuf buf) {
        ResourceLeak leak;
@ -50,6 +50,28 @@ public abstract class AbstractByteBufAllocator implements ByteBufAllocator {
        return buf;
    }

+    protected static CompositeByteBuf toLeakAwareBuffer(CompositeByteBuf buf) {
+        ResourceLeak leak;
+        switch (ResourceLeakDetector.getLevel()) {
+            case SIMPLE:
+                leak = AbstractByteBuf.leakDetector.open(buf);
+                if (leak != null) {
+                    buf = new SimpleLeakAwareCompositeByteBuf(buf, leak);
+                }
+                break;
+            case ADVANCED:
+            case PARANOID:
+                leak = AbstractByteBuf.leakDetector.open(buf);
+                if (leak != null) {
+                    buf = new AdvancedLeakAwareCompositeByteBuf(buf, leak);
+                }
+                break;
+            default:
+                break;
+        }
+        return buf;
+    }
+
    private final boolean directByDefault;
    private final ByteBuf emptyBuf;

@ -180,7 +202,7 @@ public abstract class AbstractByteBufAllocator implements ByteBufAllocator {

    @Override
    public CompositeByteBuf compositeHeapBuffer(int maxNumComponents) {
-        return new CompositeByteBuf(this, false, maxNumComponents);
+        return toLeakAwareBuffer(new CompositeByteBuf(this, false, maxNumComponents));
    }

    @Override
@ -190,7 +212,7 @@ public abstract class AbstractByteBufAllocator implements ByteBufAllocator {

    @Override
    public CompositeByteBuf compositeDirectBuffer(int maxNumComponents) {
-        return new CompositeByteBuf(this, true, maxNumComponents);
+        return toLeakAwareBuffer(new CompositeByteBuf(this, true, maxNumComponents));
    }

    private static void validate(int initialCapacity, int maxCapacity) {
--- a/buffer/src/main/java/io/netty/buffer/AbstractReferenceCountedByteBuf.java
+++ b/buffer/src/main/java/io/netty/buffer/AbstractReferenceCountedByteBuf.java
@ -44,7 +44,7 @@ public abstract class AbstractReferenceCountedByteBuf extends AbstractByteBuf {
    }

    @Override
-    public final int refCnt() {
+    public int refCnt() {
        return refCnt;
    }

@ -104,7 +104,7 @@ public abstract class AbstractReferenceCountedByteBuf extends AbstractByteBuf {
    }

    @Override
-    public final boolean release() {
+    public boolean release() {
        for (;;) {
            int refCnt = this.refCnt;
            if (refCnt == 0) {
@ -122,7 +122,7 @@ public abstract class AbstractReferenceCountedByteBuf extends AbstractByteBuf {
    }

    @Override
-    public final boolean release(int decrement) {
+    public boolean release(int decrement) {
        if (decrement <= 0) {
            throw new IllegalArgumentException("decrement: " + decrement + " (expected: > 0)");
        }
--- a/buffer/src/main/java/io/netty/buffer/AdvancedLeakAwareByteBuf.java
+++ b/buffer/src/main/java/io/netty/buffer/AdvancedLeakAwareByteBuf.java
@ -53,7 +53,7 @@ final class AdvancedLeakAwareByteBuf extends WrappedByteBuf {
        this.leak = leak;
    }

-    private void recordLeakNonRefCountingOperation() {
+    static void recordLeakNonRefCountingOperation(ResourceLeak leak) {
        if (!ACQUIRE_AND_RELEASE_ONLY) {
            leak.record();
        }
@ -61,7 +61,7 @@ final class AdvancedLeakAwareByteBuf extends WrappedByteBuf {

    @Override
    public ByteBuf order(ByteOrder endianness) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        if (order() == endianness) {
            return this;
        } else {
@ -71,775 +71,775 @@ final class AdvancedLeakAwareByteBuf extends WrappedByteBuf {

    @Override
    public ByteBuf slice() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return new AdvancedLeakAwareByteBuf(super.slice(), leak);
    }

    @Override
    public ByteBuf slice(int index, int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return new AdvancedLeakAwareByteBuf(super.slice(index, length), leak);
    }

    @Override
    public ByteBuf duplicate() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return new AdvancedLeakAwareByteBuf(super.duplicate(), leak);
    }

    @Override
    public ByteBuf readSlice(int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return new AdvancedLeakAwareByteBuf(super.readSlice(length), leak);
    }

    @Override
    public ByteBuf discardReadBytes() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.discardReadBytes();
    }

    @Override
    public ByteBuf discardSomeReadBytes() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.discardSomeReadBytes();
    }

    @Override
    public ByteBuf ensureWritable(int minWritableBytes) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.ensureWritable(minWritableBytes);
    }

    @Override
    public int ensureWritable(int minWritableBytes, boolean force) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.ensureWritable(minWritableBytes, force);
    }

    @Override
    public boolean getBoolean(int index) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getBoolean(index);
    }

    @Override
    public byte getByte(int index) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getByte(index);
    }

    @Override
    public short getUnsignedByte(int index) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getUnsignedByte(index);
    }

    @Override
    public short getShort(int index) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getShort(index);
    }

    @Override
    public int getUnsignedShort(int index) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getUnsignedShort(index);
    }

    @Override
    public int getMedium(int index) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getMedium(index);
    }

    @Override
    public int getUnsignedMedium(int index) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getUnsignedMedium(index);
    }

    @Override
    public int getInt(int index) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getInt(index);
    }

    @Override
    public long getUnsignedInt(int index) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getUnsignedInt(index);
    }

    @Override
    public long getLong(int index) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getLong(index);
    }

    @Override
    public char getChar(int index) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getChar(index);
    }

    @Override
    public float getFloat(int index) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getFloat(index);
    }

    @Override
    public double getDouble(int index) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getDouble(index);
    }

    @Override
    public ByteBuf getBytes(int index, ByteBuf dst) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getBytes(index, dst);
    }

    @Override
    public ByteBuf getBytes(int index, ByteBuf dst, int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getBytes(index, dst, length);
    }

    @Override
    public ByteBuf getBytes(int index, ByteBuf dst, int dstIndex, int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getBytes(index, dst, dstIndex, length);
    }

    @Override
    public ByteBuf getBytes(int index, byte[] dst) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getBytes(index, dst);
    }

    @Override
    public ByteBuf getBytes(int index, byte[] dst, int dstIndex, int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getBytes(index, dst, dstIndex, length);
    }

    @Override
    public ByteBuf getBytes(int index, ByteBuffer dst) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getBytes(index, dst);
    }

    @Override
    public ByteBuf getBytes(int index, OutputStream out, int length) throws IOException {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getBytes(index, out, length);
    }

    @Override
    public int getBytes(int index, GatheringByteChannel out, int length) throws IOException {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getBytes(index, out, length);
    }

    @Override
    public ByteBuf setBoolean(int index, boolean value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setBoolean(index, value);
    }

    @Override
    public ByteBuf setByte(int index, int value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setByte(index, value);
    }

    @Override
    public ByteBuf setShort(int index, int value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setShort(index, value);
    }

    @Override
    public ByteBuf setMedium(int index, int value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setMedium(index, value);
    }

    @Override
    public ByteBuf setInt(int index, int value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setInt(index, value);
    }

    @Override
    public ByteBuf setLong(int index, long value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setLong(index, value);
    }

    @Override
    public ByteBuf setChar(int index, int value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setChar(index, value);
    }

    @Override
    public ByteBuf setFloat(int index, float value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setFloat(index, value);
    }

    @Override
    public ByteBuf setDouble(int index, double value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setDouble(index, value);
    }

    @Override
    public ByteBuf setBytes(int index, ByteBuf src) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setBytes(index, src);
    }

    @Override
    public ByteBuf setBytes(int index, ByteBuf src, int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setBytes(index, src, length);
    }

    @Override
    public ByteBuf setBytes(int index, ByteBuf src, int srcIndex, int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setBytes(index, src, srcIndex, length);
    }

    @Override
    public ByteBuf setBytes(int index, byte[] src) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setBytes(index, src);
    }

    @Override
    public ByteBuf setBytes(int index, byte[] src, int srcIndex, int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setBytes(index, src, srcIndex, length);
    }

    @Override
    public ByteBuf setBytes(int index, ByteBuffer src) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setBytes(index, src);
    }

    @Override
    public int setBytes(int index, InputStream in, int length) throws IOException {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setBytes(index, in, length);
    }

    @Override
    public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setBytes(index, in, length);
    }

    @Override
    public ByteBuf setZero(int index, int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setZero(index, length);
    }

    @Override
    public boolean readBoolean() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readBoolean();
    }

    @Override
    public byte readByte() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readByte();
    }

    @Override
    public short readUnsignedByte() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readUnsignedByte();
    }

    @Override
    public short readShort() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readShort();
    }

    @Override
    public int readUnsignedShort() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readUnsignedShort();
    }

    @Override
    public int readMedium() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readMedium();
    }

    @Override
    public int readUnsignedMedium() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readUnsignedMedium();
    }

    @Override
    public int readInt() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readInt();
    }

    @Override
    public long readUnsignedInt() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readUnsignedInt();
    }

    @Override
    public long readLong() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readLong();
    }

    @Override
    public char readChar() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readChar();
    }

    @Override
    public float readFloat() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readFloat();
    }

    @Override
    public double readDouble() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readDouble();
    }

    @Override
    public ByteBuf readBytes(int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readBytes(length);
    }

    @Override
    public ByteBuf readBytes(ByteBuf dst) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readBytes(dst);
    }

    @Override
    public ByteBuf readBytes(ByteBuf dst, int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readBytes(dst, length);
    }

    @Override
    public ByteBuf readBytes(ByteBuf dst, int dstIndex, int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readBytes(dst, dstIndex, length);
    }

    @Override
    public ByteBuf readBytes(byte[] dst) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readBytes(dst);
    }

    @Override
    public ByteBuf readBytes(byte[] dst, int dstIndex, int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readBytes(dst, dstIndex, length);
    }

    @Override
    public ByteBuf readBytes(ByteBuffer dst) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readBytes(dst);
    }

    @Override
    public ByteBuf readBytes(OutputStream out, int length) throws IOException {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readBytes(out, length);
    }

    @Override
    public int readBytes(GatheringByteChannel out, int length) throws IOException {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readBytes(out, length);
    }

    @Override
    public ByteBuf skipBytes(int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.skipBytes(length);
    }

    @Override
    public ByteBuf writeBoolean(boolean value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeBoolean(value);
    }

    @Override
    public ByteBuf writeByte(int value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeByte(value);
    }

    @Override
    public ByteBuf writeShort(int value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeShort(value);
    }

    @Override
    public ByteBuf writeMedium(int value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeMedium(value);
    }

    @Override
    public ByteBuf writeInt(int value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeInt(value);
    }

    @Override
    public ByteBuf writeLong(long value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeLong(value);
    }

    @Override
    public ByteBuf writeChar(int value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeChar(value);
    }

    @Override
    public ByteBuf writeFloat(float value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeFloat(value);
    }

    @Override
    public ByteBuf writeDouble(double value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeDouble(value);
    }

    @Override
    public ByteBuf writeBytes(ByteBuf src) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeBytes(src);
    }

    @Override
    public ByteBuf writeBytes(ByteBuf src, int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeBytes(src, length);
    }

    @Override
    public ByteBuf writeBytes(ByteBuf src, int srcIndex, int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeBytes(src, srcIndex, length);
    }

    @Override
    public ByteBuf writeBytes(byte[] src) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeBytes(src);
    }

    @Override
    public ByteBuf writeBytes(byte[] src, int srcIndex, int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeBytes(src, srcIndex, length);
    }

    @Override
    public ByteBuf writeBytes(ByteBuffer src) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeBytes(src);
    }

    @Override
    public int writeBytes(InputStream in, int length) throws IOException {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeBytes(in, length);
    }

    @Override
    public int writeBytes(ScatteringByteChannel in, int length) throws IOException {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeBytes(in, length);
    }

    @Override
    public ByteBuf writeZero(int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeZero(length);
    }

    @Override
    public int indexOf(int fromIndex, int toIndex, byte value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.indexOf(fromIndex, toIndex, value);
    }

    @Override
    public int bytesBefore(byte value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.bytesBefore(value);
    }

    @Override
    public int bytesBefore(int length, byte value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.bytesBefore(length, value);
    }

    @Override
    public int bytesBefore(int index, int length, byte value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.bytesBefore(index, length, value);
    }

    @Override
    public int forEachByte(ByteProcessor processor) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.forEachByte(processor);
    }

    @Override
    public int forEachByte(int index, int length, ByteProcessor processor) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.forEachByte(index, length, processor);
    }

    @Override
    public int forEachByteDesc(ByteProcessor processor) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.forEachByteDesc(processor);
    }

    @Override
    public int forEachByteDesc(int index, int length, ByteProcessor processor) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.forEachByteDesc(index, length, processor);
    }

    @Override
    public ByteBuf copy() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.copy();
    }

    @Override
    public ByteBuf copy(int index, int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.copy(index, length);
    }

    @Override
    public int nioBufferCount() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.nioBufferCount();
    }

    @Override
    public ByteBuffer nioBuffer() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.nioBuffer();
    }

    @Override
    public ByteBuffer nioBuffer(int index, int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.nioBuffer(index, length);
    }

    @Override
    public ByteBuffer[] nioBuffers() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.nioBuffers();
    }

    @Override
    public ByteBuffer[] nioBuffers(int index, int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.nioBuffers(index, length);
    }

    @Override
    public ByteBuffer internalNioBuffer(int index, int length) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.internalNioBuffer(index, length);
    }

    @Override
    public String toString(Charset charset) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.toString(charset);
    }

    @Override
    public String toString(int index, int length, Charset charset) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.toString(index, length, charset);
    }

    @Override
    public ByteBuf capacity(int newCapacity) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.capacity(newCapacity);
    }

    @Override
    public short getShortLE(int index) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getShortLE(index);
    }

    @Override
    public int getUnsignedShortLE(int index) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getUnsignedShortLE(index);
    }

    @Override
    public int getMediumLE(int index) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getMediumLE(index);
    }

    @Override
    public int getUnsignedMediumLE(int index) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getUnsignedMediumLE(index);
    }

    @Override
    public int getIntLE(int index) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getIntLE(index);
    }

    @Override
    public long getUnsignedIntLE(int index) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getUnsignedIntLE(index);
    }

    @Override
    public long getLongLE(int index) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.getLongLE(index);
    }

    @Override
    public ByteBuf setShortLE(int index, int value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setShortLE(index, value);
    }

    @Override
    public ByteBuf setIntLE(int index, int value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setIntLE(index, value);
    }

    @Override
    public ByteBuf setMediumLE(int index, int value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setMediumLE(index, value);
    }

    @Override
    public ByteBuf setLongLE(int index, long value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.setLongLE(index, value);
    }

    @Override
    public short readShortLE() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readShortLE();
    }

    @Override
    public int readUnsignedShortLE() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readUnsignedShortLE();
    }

    @Override
    public int readMediumLE() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readMediumLE();
    }

    @Override
    public int readUnsignedMediumLE() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readUnsignedMediumLE();
    }

    @Override
    public int readIntLE() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readIntLE();
    }

    @Override
    public long readUnsignedIntLE() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readUnsignedIntLE();
    }

    @Override
    public long readLongLE() {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.readLongLE();
    }

    @Override
    public ByteBuf writeShortLE(int value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeShortLE(value);
    }

    @Override
    public ByteBuf writeMediumLE(int value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeMediumLE(value);
    }

    @Override
    public ByteBuf writeIntLE(int value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeIntLE(value);
    }

    @Override
    public ByteBuf writeLongLE(long value) {
-        recordLeakNonRefCountingOperation();
+        recordLeakNonRefCountingOperation(leak);
        return super.writeLongLE(value);
    }

--- a/buffer/src/main/java/io/netty/buffer/AdvancedLeakAwareCompositeByteBuf.java
+++ b/buffer/src/main/java/io/netty/buffer/AdvancedLeakAwareCompositeByteBuf.java
@ -0,0 +1,951 @@
+/*
+ * Copyright 2016 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.ByteProcessor;
+import io.netty.util.ResourceLeak;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.channels.GatheringByteChannel;
+import java.nio.channels.ScatteringByteChannel;
+import java.nio.charset.Charset;
+import java.util.Iterator;
+import java.util.List;
+
+import static io.netty.buffer.AdvancedLeakAwareByteBuf.recordLeakNonRefCountingOperation;
+
+final class AdvancedLeakAwareCompositeByteBuf extends WrappedCompositeByteBuf {
+
+    private final ResourceLeak leak;
+
+    AdvancedLeakAwareCompositeByteBuf(CompositeByteBuf wrapped, ResourceLeak leak) {
+        super(wrapped);
+        this.leak = leak;
+    }
+
+    @Override
+    public ByteBuf order(ByteOrder endianness) {
+        recordLeakNonRefCountingOperation(leak);
+        if (order() == endianness) {
+            return this;
+        } else {
+            return new AdvancedLeakAwareByteBuf(super.order(endianness), leak);
+        }
+    }
+
+    @Override
+    public ByteBuf slice() {
+        recordLeakNonRefCountingOperation(leak);
+        return new AdvancedLeakAwareByteBuf(super.slice(), leak);
+    }
+
+    @Override
+    public ByteBuf slice(int index, int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return new AdvancedLeakAwareByteBuf(super.slice(index, length), leak);
+    }
+
+    @Override
+    public ByteBuf duplicate() {
+        recordLeakNonRefCountingOperation(leak);
+        return new AdvancedLeakAwareByteBuf(super.duplicate(), leak);
+    }
+
+    @Override
+    public ByteBuf readSlice(int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return new AdvancedLeakAwareByteBuf(super.readSlice(length), leak);
+    }
+
+    @Override
+    public CompositeByteBuf discardReadBytes() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.discardReadBytes();
+    }
+
+    @Override
+    public CompositeByteBuf discardSomeReadBytes() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.discardSomeReadBytes();
+    }
+
+    @Override
+    public CompositeByteBuf ensureWritable(int minWritableBytes) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.ensureWritable(minWritableBytes);
+    }
+
+    @Override
+    public int ensureWritable(int minWritableBytes, boolean force) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.ensureWritable(minWritableBytes, force);
+    }
+
+    @Override
+    public boolean getBoolean(int index) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getBoolean(index);
+    }
+
+    @Override
+    public byte getByte(int index) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getByte(index);
+    }
+
+    @Override
+    public short getUnsignedByte(int index) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getUnsignedByte(index);
+    }
+
+    @Override
+    public short getShort(int index) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getShort(index);
+    }
+
+    @Override
+    public int getUnsignedShort(int index) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getUnsignedShort(index);
+    }
+
+    @Override
+    public int getMedium(int index) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getMedium(index);
+    }
+
+    @Override
+    public int getUnsignedMedium(int index) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getUnsignedMedium(index);
+    }
+
+    @Override
+    public int getInt(int index) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getInt(index);
+    }
+
+    @Override
+    public long getUnsignedInt(int index) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getUnsignedInt(index);
+    }
+
+    @Override
+    public long getLong(int index) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getLong(index);
+    }
+
+    @Override
+    public char getChar(int index) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getChar(index);
+    }
+
+    @Override
+    public float getFloat(int index) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getFloat(index);
+    }
+
+    @Override
+    public double getDouble(int index) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getDouble(index);
+    }
+
+    @Override
+    public CompositeByteBuf getBytes(int index, ByteBuf dst) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getBytes(index, dst);
+    }
+
+    @Override
+    public CompositeByteBuf getBytes(int index, ByteBuf dst, int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getBytes(index, dst, length);
+    }
+
+    @Override
+    public CompositeByteBuf getBytes(int index, ByteBuf dst, int dstIndex, int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getBytes(index, dst, dstIndex, length);
+    }
+
+    @Override
+    public CompositeByteBuf getBytes(int index, byte[] dst) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getBytes(index, dst);
+    }
+
+    @Override
+    public CompositeByteBuf getBytes(int index, byte[] dst, int dstIndex, int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getBytes(index, dst, dstIndex, length);
+    }
+
+    @Override
+    public CompositeByteBuf getBytes(int index, ByteBuffer dst) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getBytes(index, dst);
+    }
+
+    @Override
+    public CompositeByteBuf getBytes(int index, OutputStream out, int length) throws IOException {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getBytes(index, out, length);
+    }
+
+    @Override
+    public int getBytes(int index, GatheringByteChannel out, int length) throws IOException {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getBytes(index, out, length);
+    }
+
+    @Override
+    public CompositeByteBuf setBoolean(int index, boolean value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setBoolean(index, value);
+    }
+
+    @Override
+    public CompositeByteBuf setByte(int index, int value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setByte(index, value);
+    }
+
+    @Override
+    public CompositeByteBuf setShort(int index, int value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setShort(index, value);
+    }
+
+    @Override
+    public CompositeByteBuf setMedium(int index, int value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setMedium(index, value);
+    }
+
+    @Override
+    public CompositeByteBuf setInt(int index, int value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setInt(index, value);
+    }
+
+    @Override
+    public CompositeByteBuf setLong(int index, long value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setLong(index, value);
+    }
+
+    @Override
+    public CompositeByteBuf setChar(int index, int value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setChar(index, value);
+    }
+
+    @Override
+    public CompositeByteBuf setFloat(int index, float value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setFloat(index, value);
+    }
+
+    @Override
+    public CompositeByteBuf setDouble(int index, double value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setDouble(index, value);
+    }
+
+    @Override
+    public CompositeByteBuf setBytes(int index, ByteBuf src) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setBytes(index, src);
+    }
+
+    @Override
+    public CompositeByteBuf setBytes(int index, ByteBuf src, int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setBytes(index, src, length);
+    }
+
+    @Override
+    public CompositeByteBuf setBytes(int index, ByteBuf src, int srcIndex, int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setBytes(index, src, srcIndex, length);
+    }
+
+    @Override
+    public CompositeByteBuf setBytes(int index, byte[] src) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setBytes(index, src);
+    }
+
+    @Override
+    public CompositeByteBuf setBytes(int index, byte[] src, int srcIndex, int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setBytes(index, src, srcIndex, length);
+    }
+
+    @Override
+    public CompositeByteBuf setBytes(int index, ByteBuffer src) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setBytes(index, src);
+    }
+
+    @Override
+    public int setBytes(int index, InputStream in, int length) throws IOException {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setBytes(index, in, length);
+    }
+
+    @Override
+    public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setBytes(index, in, length);
+    }
+
+    @Override
+    public CompositeByteBuf setZero(int index, int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setZero(index, length);
+    }
+
+    @Override
+    public boolean readBoolean() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readBoolean();
+    }
+
+    @Override
+    public byte readByte() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readByte();
+    }
+
+    @Override
+    public short readUnsignedByte() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readUnsignedByte();
+    }
+
+    @Override
+    public short readShort() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readShort();
+    }
+
+    @Override
+    public int readUnsignedShort() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readUnsignedShort();
+    }
+
+    @Override
+    public int readMedium() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readMedium();
+    }
+
+    @Override
+    public int readUnsignedMedium() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readUnsignedMedium();
+    }
+
+    @Override
+    public int readInt() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readInt();
+    }
+
+    @Override
+    public long readUnsignedInt() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readUnsignedInt();
+    }
+
+    @Override
+    public long readLong() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readLong();
+    }
+
+    @Override
+    public char readChar() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readChar();
+    }
+
+    @Override
+    public float readFloat() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readFloat();
+    }
+
+    @Override
+    public double readDouble() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readDouble();
+    }
+
+    @Override
+    public ByteBuf readBytes(int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readBytes(length);
+    }
+
+    @Override
+    public CompositeByteBuf readBytes(ByteBuf dst) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readBytes(dst);
+    }
+
+    @Override
+    public CompositeByteBuf readBytes(ByteBuf dst, int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readBytes(dst, length);
+    }
+
+    @Override
+    public CompositeByteBuf readBytes(ByteBuf dst, int dstIndex, int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readBytes(dst, dstIndex, length);
+    }
+
+    @Override
+    public CompositeByteBuf readBytes(byte[] dst) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readBytes(dst);
+    }
+
+    @Override
+    public CompositeByteBuf readBytes(byte[] dst, int dstIndex, int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readBytes(dst, dstIndex, length);
+    }
+
+    @Override
+    public CompositeByteBuf readBytes(ByteBuffer dst) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readBytes(dst);
+    }
+
+    @Override
+    public CompositeByteBuf readBytes(OutputStream out, int length) throws IOException {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readBytes(out, length);
+    }
+
+    @Override
+    public int readBytes(GatheringByteChannel out, int length) throws IOException {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readBytes(out, length);
+    }
+
+    @Override
+    public CompositeByteBuf skipBytes(int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.skipBytes(length);
+    }
+
+    @Override
+    public CompositeByteBuf writeBoolean(boolean value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeBoolean(value);
+    }
+
+    @Override
+    public CompositeByteBuf writeByte(int value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeByte(value);
+    }
+
+    @Override
+    public CompositeByteBuf writeShort(int value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeShort(value);
+    }
+
+    @Override
+    public CompositeByteBuf writeMedium(int value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeMedium(value);
+    }
+
+    @Override
+    public CompositeByteBuf writeInt(int value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeInt(value);
+    }
+
+    @Override
+    public CompositeByteBuf writeLong(long value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeLong(value);
+    }
+
+    @Override
+    public CompositeByteBuf writeChar(int value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeChar(value);
+    }
+
+    @Override
+    public CompositeByteBuf writeFloat(float value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeFloat(value);
+    }
+
+    @Override
+    public CompositeByteBuf writeDouble(double value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeDouble(value);
+    }
+
+    @Override
+    public CompositeByteBuf writeBytes(ByteBuf src) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeBytes(src);
+    }
+
+    @Override
+    public CompositeByteBuf writeBytes(ByteBuf src, int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeBytes(src, length);
+    }
+
+    @Override
+    public CompositeByteBuf writeBytes(ByteBuf src, int srcIndex, int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeBytes(src, srcIndex, length);
+    }
+
+    @Override
+    public CompositeByteBuf writeBytes(byte[] src) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeBytes(src);
+    }
+
+    @Override
+    public CompositeByteBuf writeBytes(byte[] src, int srcIndex, int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeBytes(src, srcIndex, length);
+    }
+
+    @Override
+    public CompositeByteBuf writeBytes(ByteBuffer src) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeBytes(src);
+    }
+
+    @Override
+    public int writeBytes(InputStream in, int length) throws IOException {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeBytes(in, length);
+    }
+
+    @Override
+    public int writeBytes(ScatteringByteChannel in, int length) throws IOException {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeBytes(in, length);
+    }
+
+    @Override
+    public CompositeByteBuf writeZero(int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeZero(length);
+    }
+
+    @Override
+    public int indexOf(int fromIndex, int toIndex, byte value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.indexOf(fromIndex, toIndex, value);
+    }
+
+    @Override
+    public int bytesBefore(byte value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.bytesBefore(value);
+    }
+
+    @Override
+    public int bytesBefore(int length, byte value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.bytesBefore(length, value);
+    }
+
+    @Override
+    public int bytesBefore(int index, int length, byte value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.bytesBefore(index, length, value);
+    }
+
+    @Override
+    public int forEachByte(ByteProcessor processor) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.forEachByte(processor);
+    }
+
+    @Override
+    public int forEachByte(int index, int length, ByteProcessor processor) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.forEachByte(index, length, processor);
+    }
+
+    @Override
+    public int forEachByteDesc(ByteProcessor processor) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.forEachByteDesc(processor);
+    }
+
+    @Override
+    public int forEachByteDesc(int index, int length, ByteProcessor processor) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.forEachByteDesc(index, length, processor);
+    }
+
+    @Override
+    public ByteBuf copy() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.copy();
+    }
+
+    @Override
+    public ByteBuf copy(int index, int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.copy(index, length);
+    }
+
+    @Override
+    public int nioBufferCount() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.nioBufferCount();
+    }
+
+    @Override
+    public ByteBuffer nioBuffer() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.nioBuffer();
+    }
+
+    @Override
+    public ByteBuffer nioBuffer(int index, int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.nioBuffer(index, length);
+    }
+
+    @Override
+    public ByteBuffer[] nioBuffers() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.nioBuffers();
+    }
+
+    @Override
+    public ByteBuffer[] nioBuffers(int index, int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.nioBuffers(index, length);
+    }
+
+    @Override
+    public ByteBuffer internalNioBuffer(int index, int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.internalNioBuffer(index, length);
+    }
+
+    @Override
+    public String toString(Charset charset) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.toString(charset);
+    }
+
+    @Override
+    public String toString(int index, int length, Charset charset) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.toString(index, length, charset);
+    }
+
+    @Override
+    public CompositeByteBuf capacity(int newCapacity) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.capacity(newCapacity);
+    }
+
+    @Override
+    public short getShortLE(int index) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getShortLE(index);
+    }
+
+    @Override
+    public int getUnsignedShortLE(int index) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getUnsignedShortLE(index);
+    }
+
+    @Override
+    public int getUnsignedMediumLE(int index) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getUnsignedMediumLE(index);
+    }
+
+    @Override
+    public int getMediumLE(int index) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getMediumLE(index);
+    }
+
+    @Override
+    public int getIntLE(int index) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getIntLE(index);
+    }
+
+    @Override
+    public long getUnsignedIntLE(int index) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getUnsignedIntLE(index);
+    }
+
+    @Override
+    public long getLongLE(int index) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.getLongLE(index);
+    }
+
+    @Override
+    public ByteBuf setShortLE(int index, int value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setShortLE(index, value);
+    }
+
+    @Override
+    public ByteBuf setMediumLE(int index, int value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setMediumLE(index, value);
+    }
+
+    @Override
+    public ByteBuf setIntLE(int index, int value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setIntLE(index, value);
+    }
+
+    @Override
+    public ByteBuf setLongLE(int index, long value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.setLongLE(index, value);
+    }
+
+    @Override
+    public short readShortLE() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readShortLE();
+    }
+
+    @Override
+    public int readUnsignedShortLE() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readUnsignedShortLE();
+    }
+
+    @Override
+    public int readMediumLE() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readMediumLE();
+    }
+
+    @Override
+    public int readUnsignedMediumLE() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readUnsignedMediumLE();
+    }
+
+    @Override
+    public int readIntLE() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readIntLE();
+    }
+
+    @Override
+    public long readUnsignedIntLE() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readUnsignedIntLE();
+    }
+
+    @Override
+    public long readLongLE() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.readLongLE();
+    }
+
+    @Override
+    public ByteBuf writeShortLE(int value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeShortLE(value);
+    }
+
+    @Override
+    public ByteBuf writeMediumLE(int value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeMediumLE(value);
+    }
+
+    @Override
+    public ByteBuf writeIntLE(int value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeIntLE(value);
+    }
+
+    @Override
+    public ByteBuf writeLongLE(long value) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.writeLongLE(value);
+    }
+
+    @Override
+    public CompositeByteBuf addComponent(ByteBuf buffer) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.addComponent(buffer);
+    }
+
+    @Override
+    public CompositeByteBuf addComponents(ByteBuf... buffers) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.addComponents(buffers);
+    }
+
+    @Override
+    public CompositeByteBuf addComponents(Iterable<ByteBuf> buffers) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.addComponents(buffers);
+    }
+
+    @Override
+    public CompositeByteBuf addComponent(int cIndex, ByteBuf buffer) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.addComponent(cIndex, buffer);
+    }
+
+    @Override
+    public CompositeByteBuf addComponents(int cIndex, ByteBuf... buffers) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.addComponents(cIndex, buffers);
+    }
+
+    @Override
+    public CompositeByteBuf removeComponent(int cIndex) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.removeComponent(cIndex);
+    }
+
+    @Override
+    public CompositeByteBuf addComponents(int cIndex, Iterable<ByteBuf> buffers) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.addComponents(cIndex, buffers);
+    }
+
+    @Override
+    public CompositeByteBuf removeComponents(int cIndex, int numComponents) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.removeComponents(cIndex, numComponents);
+    }
+
+    @Override
+    public Iterator<ByteBuf> iterator() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.iterator();
+    }
+
+    @Override
+    public List<ByteBuf> decompose(int offset, int length) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.decompose(offset, length);
+    }
+
+    @Override
+    public CompositeByteBuf consolidate() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.consolidate();
+    }
+
+    @Override
+    public CompositeByteBuf discardReadComponents() {
+        recordLeakNonRefCountingOperation(leak);
+        return super.discardReadComponents();
+    }
+
+    @Override
+    public CompositeByteBuf consolidate(int cIndex, int numComponents) {
+        recordLeakNonRefCountingOperation(leak);
+        return super.consolidate(cIndex, numComponents);
+    }
+
+    @Override
+    public CompositeByteBuf retain() {
+        leak.record();
+        return super.retain();
+    }
+
+    @Override
+    public CompositeByteBuf retain(int increment) {
+        leak.record();
+        return super.retain(increment);
+    }
+
+    @Override
+    public CompositeByteBuf touch() {
+        leak.record();
+        return this;
+    }
+
+    @Override
+    public CompositeByteBuf touch(Object hint) {
+        leak.record(hint);
+        return this;
+    }
+
+    @Override
+    public boolean release() {
+        boolean deallocated = super.release();
+        if (deallocated) {
+            leak.close();
+        } else {
+            leak.record();
+        }
+        return deallocated;
+    }
+
+    @Override
+    public boolean release(int decrement) {
+        boolean deallocated = super.release(decrement);
+        if (deallocated) {
+            leak.close();
+        } else {
+            leak.record();
+        }
+        return deallocated;
+    }
+}
--- a/buffer/src/main/java/io/netty/buffer/CompositeByteBuf.java
+++ b/buffer/src/main/java/io/netty/buffer/CompositeByteBuf.java
@ -15,7 +15,6 @@
 */
 package io.netty.buffer;

-import io.netty.util.ResourceLeak;
 import io.netty.util.internal.EmptyArrays;

 import java.io.IOException;
@ -44,10 +43,9 @@ public class CompositeByteBuf extends AbstractReferenceCountedByteBuf implements
    private static final ByteBuffer EMPTY_NIO_BUFFER = Unpooled.EMPTY_BUFFER.nioBuffer();
    private static final Iterator<ByteBuf> EMPTY_ITERATOR = Collections.<ByteBuf>emptyList().iterator();

-    private final ResourceLeak leak;
    private final ByteBufAllocator alloc;
    private final boolean direct;
-    private final List<Component> components = new ArrayList<Component>();
+    private final List<Component> components;
    private final int maxNumComponents;

    private boolean freed;
@ -60,7 +58,7 @@ public class CompositeByteBuf extends AbstractReferenceCountedByteBuf implements
        this.alloc = alloc;
        this.direct = direct;
        this.maxNumComponents = maxNumComponents;
-        leak = leakDetector.open(this);
+        components = newList(maxNumComponents);
    }

    public CompositeByteBuf(ByteBufAllocator alloc, boolean direct, int maxNumComponents, ByteBuf... buffers) {
@ -76,11 +74,11 @@ public class CompositeByteBuf extends AbstractReferenceCountedByteBuf implements
        this.alloc = alloc;
        this.direct = direct;
        this.maxNumComponents = maxNumComponents;
+        components = newList(maxNumComponents);

        addComponents0(0, buffers);
        consolidateIfNeeded();
        setIndex(0, capacity());
-        leak = leakDetector.open(this);
    }

    public CompositeByteBuf(
@ -97,10 +95,24 @@ public class CompositeByteBuf extends AbstractReferenceCountedByteBuf implements
        this.alloc = alloc;
        this.direct = direct;
        this.maxNumComponents = maxNumComponents;
+        components = newList(maxNumComponents);
+
        addComponents0(0, buffers);
        consolidateIfNeeded();
        setIndex(0, capacity());
-        leak = leakDetector.open(this);
+    }
+
+    private static List<Component> newList(int maxNumComponents) {
+        return new ArrayList<Component>(Math.min(AbstractByteBufAllocator.DEFAULT_MAX_COMPONENTS, maxNumComponents));
+    }
+
+    // Special constructor used by WrappedCompositeByteBuf
+    CompositeByteBuf(ByteBufAllocator alloc) {
+        super(Integer.MAX_VALUE);
+        this.alloc = alloc;
+        direct = false;
+        maxNumComponents = 0;
+        components = Collections.emptyList();
    }

    /**
@ -1707,17 +1719,11 @@ public class CompositeByteBuf extends AbstractReferenceCountedByteBuf implements

    @Override
    public CompositeByteBuf touch() {
-        if (leak != null) {
-            leak.record();
-        }
        return this;
    }

    @Override
    public CompositeByteBuf touch(Object hint) {
-        if (leak != null) {
-            leak.record(hint);
-        }
        return this;
    }

@ -1744,10 +1750,6 @@ public class CompositeByteBuf extends AbstractReferenceCountedByteBuf implements
        for (int i = 0; i < size; i++) {
            components.get(i).freeIfNecessary();
        }
-
-        if (leak != null) {
-            leak.close();
-        }
    }

    @Override
--- a/buffer/src/main/java/io/netty/buffer/SimpleLeakAwareCompositeByteBuf.java
+++ b/buffer/src/main/java/io/netty/buffer/SimpleLeakAwareCompositeByteBuf.java
@ -0,0 +1,79 @@
+/*
+ * Copyright 2016 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.ResourceLeak;
+
+import java.nio.ByteOrder;
+
+final class SimpleLeakAwareCompositeByteBuf extends WrappedCompositeByteBuf {
+
+    private final ResourceLeak leak;
+
+    SimpleLeakAwareCompositeByteBuf(CompositeByteBuf wrapped, ResourceLeak leak) {
+        super(wrapped);
+        this.leak = leak;
+    }
+
+    @Override
+    public boolean release() {
+        boolean deallocated = super.release();
+        if (deallocated) {
+            leak.close();
+        }
+        return deallocated;
+    }
+
+    @Override
+    public boolean release(int decrement) {
+        boolean deallocated = super.release(decrement);
+        if (deallocated) {
+            leak.close();
+        }
+        return deallocated;
+    }
+
+    @Override
+    public ByteBuf order(ByteOrder endianness) {
+        leak.record();
+        if (order() == endianness) {
+            return this;
+        } else {
+            return new SimpleLeakAwareByteBuf(super.order(endianness), leak);
+        }
+    }
+
+    @Override
+    public ByteBuf slice() {
+        return new SimpleLeakAwareByteBuf(super.slice(), leak);
+    }
+
+    @Override
+    public ByteBuf slice(int index, int length) {
+        return new SimpleLeakAwareByteBuf(super.slice(index, length), leak);
+    }
+
+    @Override
+    public ByteBuf duplicate() {
+        return new SimpleLeakAwareByteBuf(super.duplicate(), leak);
+    }
+
+    @Override
+    public ByteBuf readSlice(int length) {
+        return new SimpleLeakAwareByteBuf(super.readSlice(length), leak);
+    }
+}
--- a/buffer/src/main/java/io/netty/buffer/Unpooled.java
+++ b/buffer/src/main/java/io/netty/buffer/Unpooled.java
@ -230,7 +230,7 @@ public final class Unpooled {
     * content will be visible to the returned buffer.
     */
    public static ByteBuf wrappedBuffer(byte[]... arrays) {
-        return wrappedBuffer(16, arrays);
+        return wrappedBuffer(AbstractByteBufAllocator.DEFAULT_MAX_COMPONENTS, arrays);
    }

    /**
@ -241,7 +241,7 @@ public final class Unpooled {
     * @return The readable portion of the {@code buffers}. The caller is responsible for releasing this buffer.
     */
    public static ByteBuf wrappedBuffer(ByteBuf... buffers) {
-        return wrappedBuffer(16, buffers);
+        return wrappedBuffer(AbstractByteBufAllocator.DEFAULT_MAX_COMPONENTS, buffers);
    }

    /**
@ -250,7 +250,7 @@ public final class Unpooled {
     * specified buffers will be visible to the returned buffer.
     */
    public static ByteBuf wrappedBuffer(ByteBuffer... buffers) {
-        return wrappedBuffer(16, buffers);
+        return wrappedBuffer(AbstractByteBufAllocator.DEFAULT_MAX_COMPONENTS, buffers);
    }

    /**
@ -358,7 +358,7 @@ public final class Unpooled {
     * Returns a new big-endian composite buffer with no components.
     */
    public static CompositeByteBuf compositeBuffer() {
-        return compositeBuffer(16);
+        return compositeBuffer(AbstractByteBufAllocator.DEFAULT_MAX_COMPONENTS);
    }

    /**
--- a/buffer/src/main/java/io/netty/buffer/WrappedCompositeByteBuf.java
+++ b/buffer/src/main/java/io/netty/buffer/WrappedCompositeByteBuf.java