Add IllegalBufferAccessException and checks on MessageBuf impls

- Related: #827

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

@@ -17,6 +17,7 @@ package io.netty.buffer;
 
 import java.util.ArrayDeque;
 import java.util.Collection;
+import java.util.Iterator;
 
 final class DefaultMessageBuf<T> extends ArrayDeque<T> implements MessageBuf<T> {
 
@@ -35,8 +36,111 @@ final class DefaultMessageBuf<T> extends ArrayDeque<T> implements MessageBuf<T>
         return BufType.MESSAGE;
     }
 
+    @Override
+    public void addFirst(T t) {
+        ensureValid();
+        super.addFirst(t);
+    }
+
+    @Override
+    public void addLast(T t) {
+        ensureValid();
+        super.addLast(t);
+    }
+
+    @Override
+    public T pollFirst() {
+        ensureValid();
+        return super.pollFirst();
+    }
+
+    @Override
+    public T pollLast() {
+        ensureValid();
+        return super.pollLast();
+    }
+
+    @Override
+    public T getFirst() {
+        ensureValid();
+        return super.getFirst();
+    }
+
+    @Override
+    public T getLast() {
+        ensureValid();
+        return super.getLast();
+    }
+
+    @Override
+    public T peekFirst() {
+        ensureValid();
+        return super.peekFirst();
+    }
+
+    @Override
+    public T peekLast() {
+        ensureValid();
+        return super.peekLast();
+    }
+
+    @Override
+    public boolean removeFirstOccurrence(Object o) {
+        ensureValid();
+        return super.removeFirstOccurrence(o);
+    }
+
+    @Override
+    public boolean removeLastOccurrence(Object o) {
+        ensureValid();
+        return super.removeLastOccurrence(o);
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+        ensureValid();
+        return super.iterator();
+    }
+
+    @Override
+    public Iterator<T> descendingIterator() {
+        ensureValid();
+        return super.descendingIterator();
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        ensureValid();
+        return super.contains(o);
+    }
+
+    @Override
+    public void clear() {
+        ensureValid();
+        super.clear();
+    }
+
+    @Override
+    public Object[] toArray() {
+        ensureValid();
+        return super.toArray();
+    }
+
+    @Override
+    public <T1 extends Object> T1[] toArray(T1[] a) {
+        ensureValid();
+        return super.toArray(a);
+    }
+
+    @Override
+    public ArrayDeque<T> clone() {
+        ensureValid();
+        return super.clone();
+    }
+
     @Override
     public int drainTo(Collection<? super T> c) {
+        ensureValid();
         int cnt = 0;
         for (;;) {
             T o = poll();
@@ -51,6 +155,7 @@ final class DefaultMessageBuf<T> extends ArrayDeque<T> implements MessageBuf<T>
 
     @Override
     public int drainTo(Collection<? super T> c, int maxElements) {
+        ensureValid();
         int cnt = 0;
         while (cnt < maxElements) {
             T o = poll();
@@ -71,5 +176,12 @@ final class DefaultMessageBuf<T> extends ArrayDeque<T> implements MessageBuf<T>
     @Override
     public void free() {
         freed = true;
+        super.clear();
+    }
+
+    private void ensureValid() {
+        if (freed) {
+            throw new IllegalBufferAccessException();
+        }
     }
 }

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

@@ -17,24 +17,24 @@
 package io.netty.buffer;
 
 /**
- * A {@link RuntimeException} raised by a {@link ByteBuf} where a user requested an operation on a freed
- * {@link ByteBuf}.
+ * An {@link IllegalStateException} raised when a user attempts to access a {@link Buf} which was freed by
+ * {@link Buf#free()} already.
  */
-public class IllegalMemoryAccessException extends RuntimeException {
+public class IllegalBufferAccessException extends IllegalStateException {
 
     private static final long serialVersionUID = -6734326916218551327L;
 
-    public IllegalMemoryAccessException() { }
+    public IllegalBufferAccessException() { }
 
-    public IllegalMemoryAccessException(String message) {
+    public IllegalBufferAccessException(String message) {
         super(message);
     }
 
-    public IllegalMemoryAccessException(String message, Throwable cause) {
+    public IllegalBufferAccessException(String message, Throwable cause) {
         super(message, cause);
     }
 
-    public IllegalMemoryAccessException(Throwable cause) {
+    public IllegalBufferAccessException(Throwable cause) {
         super(cause);
     }
 }

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

@@ -38,96 +38,115 @@ final class QueueBackedMessageBuf<T> implements MessageBuf<T> {
 
     @Override
     public boolean add(T e) {
+        ensureValid();
         return queue.add(e);
     }
 
     @Override
     public boolean offer(T e) {
+        ensureValid();
         return queue.offer(e);
     }
 
     @Override
     public T remove() {
+        ensureValid();
         return queue.remove();
     }
 
     @Override
     public T poll() {
+        ensureValid();
         return queue.poll();
     }
 
     @Override
     public T element() {
+        ensureValid();
         return queue.element();
     }
 
     @Override
     public T peek() {
+        ensureValid();
         return queue.peek();
     }
 
     @Override
     public int size() {
+        ensureValid();
         return queue.size();
     }
 
     @Override
     public boolean isEmpty() {
+        ensureValid();
         return queue.isEmpty();
     }
 
     @Override
     public boolean contains(Object o) {
+        ensureValid();
         return queue.contains(o);
     }
 
     @Override
     public Iterator<T> iterator() {
+        ensureValid();
         return queue.iterator();
     }
 
     @Override
     public Object[] toArray() {
+        ensureValid();
         return queue.toArray();
     }
 
     @Override
     public <E> E[] toArray(E[] a) {
+        ensureValid();
         return queue.toArray(a);
     }
 
     @Override
     public boolean remove(Object o) {
+        ensureValid();
         return queue.remove(o);
     }
 
     @Override
     public boolean containsAll(Collection<?> c) {
+        ensureValid();
         return queue.containsAll(c);
     }
 
     @Override
     public boolean addAll(Collection<? extends T> c) {
+        ensureValid();
         return queue.addAll(c);
     }
 
     @Override
     public boolean removeAll(Collection<?> c) {
+        ensureValid();
         return queue.removeAll(c);
     }
 
     @Override
     public boolean retainAll(Collection<?> c) {
+        ensureValid();
         return queue.retainAll(c);
     }
 
     @Override
     public void clear() {
+        ensureValid();
         queue.clear();
     }
 
     @Override
     public int drainTo(Collection<? super T> c) {
+        ensureValid();
         int cnt = 0;
         for (;;) {
             T o = poll();
@@ -142,6 +161,7 @@ final class QueueBackedMessageBuf<T> implements MessageBuf<T> {
 
     @Override
     public int drainTo(Collection<? super T> c, int maxElements) {
+        ensureValid();
         int cnt = 0;
         while (cnt < maxElements) {
             T o = poll();
@@ -162,10 +182,17 @@ final class QueueBackedMessageBuf<T> implements MessageBuf<T> {
     @Override
     public void free() {
         freed = true;
+        queue.clear();
     }
 
     @Override
     public String toString() {
         return queue.toString();
     }
+
+    private void ensureValid() {
+        if (freed) {
+            throw new IllegalBufferAccessException();
+        }
+    }
 }