Fix issue #472 (#473)

* Align and add some missing overloads for ByteBuffer
* Add the workaround for case 1 in #436
* Remove Deque.cs from DotNetty.Common
* Fix false positive resource leak report.
* Change some behavior of ResourceLeakDetector

Author: yyjdelete

src/DotNetty.Buffers/AbstractByteBuffer.cs

@@ -560,16 +560,20 @@ public virtual IByteBuffer SetShortLE(int index, int value)
 
         protected internal abstract void _SetShortLE(int index, int value);
 
-        public virtual IByteBuffer SetUnsignedShort(int index, ushort value)
+        public IByteBuffer SetUnsignedShort(int index, ushort value)
         {
-            this.SetShort(index, value);
-            return this;
+            unchecked
+            {
+                return this.SetShort(index, (short)value);
+            }
         }
 
-        public virtual IByteBuffer SetUnsignedShortLE(int index, ushort value)
+        public IByteBuffer SetUnsignedShortLE(int index, ushort value)
         {
-            this.SetShortLE(index, value);
-            return this;
+            unchecked
+            {
+                return this.SetShortLE(index, (short)value);
+            }
         }
 
         public virtual IByteBuffer SetChar(int index, char value)

src/DotNetty.Buffers/AdvancedLeakAwareByteBuffer.cs

@@ -771,6 +771,30 @@ public override IReferenceCounted Retain(int increment)
             return base.Retain(increment);
         }
 
+        public override IByteBuffer RetainedSlice()
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.RetainedSlice();
+        }
+
+        public override IByteBuffer RetainedSlice(int index, int length)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.RetainedSlice(index, length);
+        }
+
+        public override IByteBuffer RetainedDuplicate()
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.RetainedDuplicate();
+        }
+
+        public override IByteBuffer ReadRetainedSlice(int length)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.ReadRetainedSlice(length);
+        }
+
         public override IReferenceCounted Touch()
         {
             this.Leak.Record();

src/DotNetty.Buffers/AdvancedLeakAwareCompositeByteBuffer.cs

@@ -4,6 +4,7 @@
 namespace DotNetty.Buffers
 {
     using System;
+    using System.Collections.Generic;
     using System.IO;
     using System.Text;
     using System.Threading;
@@ -593,6 +594,156 @@ public override IByteBuffer GetBytes(int index, Stream destination, int length)
             return base.GetBytes(index, destination, length);
         }
 
+        public override CompositeByteBuffer AddComponent(bool increaseWriterIndex, IByteBuffer buffer)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.AddComponent(increaseWriterIndex, buffer);
+        }
+
+        public override CompositeByteBuffer AddComponent(bool increaseWriterIndex, int cIndex, IByteBuffer buffer)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.AddComponent(increaseWriterIndex, cIndex, buffer);
+        }
+
+        public override CompositeByteBuffer AddComponent(IByteBuffer buffer)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.AddComponent(buffer);
+        }
+
+        public override CompositeByteBuffer AddComponent(int cIndex, IByteBuffer buffer)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.AddComponent(cIndex, buffer);
+        }
+
+        public override CompositeByteBuffer AddComponents(bool increaseWriterIndex, params IByteBuffer[] buffers)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.AddComponents(increaseWriterIndex, buffers);
+        }
+
+        public override CompositeByteBuffer AddComponents(bool increaseWriterIndex, IEnumerable<IByteBuffer> buffers)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.AddComponents(increaseWriterIndex, buffers);
+        }
+
+        public override CompositeByteBuffer AddComponents(IEnumerable<IByteBuffer> buffers)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.AddComponents(buffers);
+        }
+
+        public override CompositeByteBuffer AddComponents(int cIndex, IEnumerable<IByteBuffer> buffers)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.AddComponents(cIndex, buffers);
+        }
+
+        public override CompositeByteBuffer AddComponents(int cIndex, params IByteBuffer[] buffers)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.AddComponents(cIndex, buffers);
+        }
+
+        public override CompositeByteBuffer AddComponents(params IByteBuffer[] buffers)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.AddComponents(buffers);
+        }
+
+        public override CompositeByteBuffer RemoveComponent(int cIndex)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.RemoveComponent(cIndex);
+        }
+
+        public override CompositeByteBuffer RemoveComponents(int cIndex, int numComponents)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.RemoveComponents(cIndex, numComponents);
+        }
+
+        public override CompositeByteBuffer Consolidate()
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.Consolidate();
+        }
+
+        public override CompositeByteBuffer Consolidate(int cIndex, int numComponents)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.Consolidate(cIndex, numComponents);
+        }
+
+        public override CompositeByteBuffer DiscardReadComponents()
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.DiscardReadComponents();
+        }
+
+        public override IList<IByteBuffer> Decompose(int offset, int length)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.Decompose(offset, length);
+        }
+
+        public override ICharSequence GetCharSequence(int index, int length, Encoding encoding)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.GetCharSequence(index, length, encoding);
+        }
+
+        public override ICharSequence ReadCharSequence(int length, Encoding encoding)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.ReadCharSequence(length, encoding);
+        }
+
+        public override int SetCharSequence(int index, ICharSequence sequence, Encoding encoding)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.SetCharSequence(index, sequence, encoding);
+        }
+
+        public override int WriteCharSequence(ICharSequence sequence, Encoding encoding)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.WriteCharSequence(sequence, encoding);
+        }
+
+        public override string GetString(int index, int length, Encoding encoding)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.GetString(index, length, encoding);
+        }
+
+        public override string ReadString(int length, Encoding encoding)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.ReadString(length, encoding);
+        }
+
+        public override int SetString(int index, string value, Encoding encoding)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.SetString(index, value, encoding);
+        }
+
+        public override int WriteString(string value, Encoding encoding)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.WriteString(value, encoding);
+        }
+
+        public override IEnumerator<IByteBuffer> GetEnumerator()
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.GetEnumerator();
+        }
+
         public override IReferenceCounted Retain()
         {
             this.Leak.Record();
@@ -605,6 +756,30 @@ public override IReferenceCounted Retain(int increment)
             return base.Retain(increment);
         }
 
+        public override IByteBuffer RetainedSlice()
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.RetainedSlice();
+        }
+
+        public override IByteBuffer RetainedSlice(int index, int length)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.RetainedSlice(index, length);
+        }
+
+        public override IByteBuffer RetainedDuplicate()
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.RetainedDuplicate();
+        }
+
+        public override IByteBuffer ReadRetainedSlice(int length)
+        {
+            RecordLeakNonRefCountingOperation(this.Leak);
+            return base.ReadRetainedSlice(length);
+        }
+
         public override bool Release()
         {
             this.Leak.Record();

src/DotNetty.Buffers/SimpleLeakAwareCompositeByteBuffer.cs

@@ -61,6 +61,14 @@ void CloseLeak(IByteBuffer trackedByteBuf)
 
         public override IByteBuffer ReadSlice(int length) => this.NewLeakAwareByteBuffer(base.ReadSlice(length));
 
+        public override IByteBuffer RetainedSlice() => this.NewLeakAwareByteBuffer(base.RetainedSlice());
+
+        public override IByteBuffer RetainedSlice(int index, int length) => this.NewLeakAwareByteBuffer(base.RetainedSlice(index, length));
+
+        public override IByteBuffer RetainedDuplicate() => this.NewLeakAwareByteBuffer(base.RetainedDuplicate());
+
+        public override IByteBuffer ReadRetainedSlice(int length) => this.NewLeakAwareByteBuffer(base.ReadRetainedSlice(length));
+
         SimpleLeakAwareByteBuffer NewLeakAwareByteBuffer(IByteBuffer wrapped) => this.NewLeakAwareByteBuffer(wrapped, this.Unwrap(), this.Leak);
 
         protected virtual SimpleLeakAwareByteBuffer NewLeakAwareByteBuffer(IByteBuffer wrapped, IByteBuffer trackedByteBuf, IResourceLeakTracker leakTracker) =>

src/DotNetty.Buffers/UnpooledUnsafeDirectByteBuffer.cs

@@ -297,7 +297,9 @@ public override Task<int> SetBytesAsync(int index, Stream src, int length, Cance
         {
             this.CheckIndex(index, length);
             fixed (byte* addr = &this.Addr(index))
+            {
                 return UnsafeByteBufferUtil.SetBytesAsync(this, addr, index, src, length, cancellationToken);
+            }
         }
 
         public override int IoBufferCount => 1;

src/DotNetty.Buffers/WrappedCompositeByteBuffer.cs

@@ -110,13 +110,13 @@ internal WrappedCompositeByteBuffer(CompositeByteBuffer wrapped) : base(wrapped.
 
         public override int ForEachByteDesc(int index, int length, IByteProcessor processor) => this.wrapped.ForEachByteDesc(index, length, processor);
 
-        public override int GetHashCode() => this.wrapped.GetHashCode();
+        public sealed override int GetHashCode() => this.wrapped.GetHashCode();
 
-        public override bool Equals(IByteBuffer buf) => this.wrapped.Equals(buf);
+        public sealed override bool Equals(IByteBuffer buf) => this.wrapped.Equals(buf);
 
-        public override int CompareTo(IByteBuffer that) => this.wrapped.CompareTo(that);
+        public sealed override int CompareTo(IByteBuffer that) => this.wrapped.CompareTo(that);
 
-        public override int ReferenceCount => this.wrapped.ReferenceCount;
+        public sealed override int ReferenceCount => this.wrapped.ReferenceCount;
 
         public override IByteBuffer Duplicate() => this.wrapped.Duplicate();
 
@@ -669,5 +669,25 @@ public override IByteBuffer DiscardSomeReadBytes()
         protected internal sealed override void Deallocate() => this.wrapped.Deallocate();
 
         public sealed override IByteBuffer Unwrap() => this.wrapped;
+
+        public sealed override IntPtr AddressOfPinnedMemory() => this.wrapped.AddressOfPinnedMemory();
+
+        public sealed override ref byte GetPinnableMemoryAddress() => ref this.wrapped.GetPinnableMemoryAddress();
+
+        public sealed override bool HasMemoryAddress => this.wrapped.HasMemoryAddress;
+
+        public sealed override bool IsWritable(int size) => this.wrapped.IsWritable(size);
+
+        public sealed override int MaxCapacity => this.wrapped.MaxCapacity;
+
+        public sealed override bool IsDirect => this.wrapped.IsDirect;
+
+        public override IByteBuffer ReadRetainedSlice(int length) => this.wrapped.ReadRetainedSlice(length);
+
+        public override IByteBuffer RetainedDuplicate() => this.wrapped.RetainedDuplicate();
+
+        public override IByteBuffer RetainedSlice() => this.wrapped.RetainedSlice();
+
+        public override IByteBuffer RetainedSlice(int index, int length) => this.wrapped.RetainedSlice(index, length);
     }
 }