From 2fddfb8b89758364c5ec3c09b8a34e77871ed33a Mon Sep 17 00:00:00 2001
From: Norman Maurer <norman_maurer@apple.com>
Date: Tue, 30 Aug 2016 15:13:23 +0200
Subject: [PATCH] Share code between retain(...) and release(...)
 implementations.

Motivation:

We can share the code in retain() and retain(...) and also in release() and release(...).

Modifications:

Share code.

Result:

Less duplicated code.
---
 .../AbstractReferenceCountedByteBuf.java      | 44 ++++-------------
 .../netty/util/AbstractReferenceCounted.java  | 47 +++++--------------
 2 files changed, 22 insertions(+), 69 deletions(-)

diff --git a/buffer/src/main/java/io/netty/buffer/AbstractReferenceCountedByteBuf.java b/buffer/src/main/java/io/netty/buffer/AbstractReferenceCountedByteBuf.java
index 3488206ca4b..33a7a0c17c7 100644
--- a/buffer/src/main/java/io/netty/buffer/AbstractReferenceCountedByteBuf.java
+++ b/buffer/src/main/java/io/netty/buffer/AbstractReferenceCountedByteBuf.java
@@ -21,6 +21,8 @@
 
 import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 
+import static io.netty.util.internal.ObjectUtil.checkPositive;
+
 /**
  * Abstract base class for {@link ByteBuf} implementations that count references.
  */
@@ -57,27 +59,15 @@ protected final void setRefCnt(int refCnt) {
 
     @Override
     public ByteBuf retain() {
-        for (;;) {
-            int refCnt = this.refCnt;
-            final int nextCnt = refCnt + 1;
-
-            // Ensure we not resurrect (which means the refCnt was 0) and also that we encountered an overflow.
-            if (nextCnt <= 1) {
-                throw new IllegalReferenceCountException(refCnt, 1);
-            }
-            if (refCntUpdater.compareAndSet(this, refCnt, nextCnt)) {
-                break;
-            }
-        }
-        return this;
+        return retain0(1);
     }
 
     @Override
     public ByteBuf retain(int increment) {
-        if (increment <= 0) {
-            throw new IllegalArgumentException("increment: " + increment + " (expected: > 0)");
-        }
+        return retain0(checkPositive(increment, "increment"));
+    }
 
+    private ByteBuf retain0(int increment) {
         for (;;) {
             int refCnt = this.refCnt;
             final int nextCnt = refCnt + increment;
@@ -95,28 +85,15 @@ public ByteBuf retain(int increment) {
 
     @Override
     public boolean release() {
-        for (;;) {
-            int refCnt = this.refCnt;
-            if (refCnt == 0) {
-                throw new IllegalReferenceCountException(0, -1);
-            }
-
-            if (refCntUpdater.compareAndSet(this, refCnt, refCnt - 1)) {
-                if (refCnt == 1) {
-                    deallocate();
-                    return true;
-                }
-                return false;
-            }
-        }
+        return release0(1);
     }
 
     @Override
     public boolean release(int decrement) {
-        if (decrement <= 0) {
-            throw new IllegalArgumentException("decrement: " + decrement + " (expected: > 0)");
-        }
+        return release0(checkPositive(decrement, "decrement"));
+    }
 
+    private boolean release0(int decrement) {
         for (;;) {
             int refCnt = this.refCnt;
             if (refCnt < decrement) {
@@ -132,7 +109,6 @@ public boolean release(int decrement) {
             }
         }
     }
-
     /**
      * Called once {@link #refCnt()} is equals 0.
      */
diff --git a/common/src/main/java/io/netty/util/AbstractReferenceCounted.java b/common/src/main/java/io/netty/util/AbstractReferenceCounted.java
index 44497a3774d..2e3f4d6abe8 100644
--- a/common/src/main/java/io/netty/util/AbstractReferenceCounted.java
+++ b/common/src/main/java/io/netty/util/AbstractReferenceCounted.java
@@ -19,6 +19,8 @@
 
 import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 
+import static io.netty.util.internal.ObjectUtil.checkPositive;
+
 /**
  * Abstract base class for classes wants to implement {@link ReferenceCounted}.
  */
@@ -51,27 +53,15 @@ protected final void setRefCnt(int refCnt) {
 
     @Override
     public ReferenceCounted retain() {
-        for (;;) {
-            int refCnt = this.refCnt;
-            final int nextCnt = refCnt + 1;
-
-            // Ensure we not resurrect (which means the refCnt was 0) and also that we encountered an overflow.
-            if (nextCnt <= 1) {
-                throw new IllegalReferenceCountException(refCnt, 1);
-            }
-            if (refCntUpdater.compareAndSet(this, refCnt, nextCnt)) {
-                break;
-            }
-        }
-        return this;
+        return retain0(1);
     }
 
     @Override
     public ReferenceCounted retain(int increment) {
-        if (increment <= 0) {
-            throw new IllegalArgumentException("increment: " + increment + " (expected: > 0)");
-        }
+        return retain0(checkPositive(increment, "increment"));
+    }
 
+    private ReferenceCounted retain0(int increment) {
         for (;;) {
             int refCnt = this.refCnt;
             final int nextCnt = refCnt + increment;
@@ -88,29 +78,16 @@ public ReferenceCounted retain(int increment) {
     }
 
     @Override
-    public final boolean release() {
-        for (;;) {
-            int refCnt = this.refCnt;
-            if (refCnt == 0) {
-                throw new IllegalReferenceCountException(0, -1);
-            }
-
-            if (refCntUpdater.compareAndSet(this, refCnt, refCnt - 1)) {
-                if (refCnt == 1) {
-                    deallocate();
-                    return true;
-                }
-                return false;
-            }
-        }
+    public boolean release() {
+        return release0(1);
     }
 
     @Override
-    public final boolean release(int decrement) {
-        if (decrement <= 0) {
-            throw new IllegalArgumentException("decrement: " + decrement + " (expected: > 0)");
-        }
+    public boolean release(int decrement) {
+        return release0(checkPositive(decrement, "decrement"));
+    }
 
+    private boolean release0(int decrement) {
         for (;;) {
             int refCnt = this.refCnt;
             if (refCnt < decrement) {