diff --git a/codec/src/main/java/io/netty/handler/codec/LengthFieldBasedFrameDecoder.java b/codec/src/main/java/io/netty/handler/codec/LengthFieldBasedFrameDecoder.java
index fe387e1e10..4d94bdf881 100644
--- a/codec/src/main/java/io/netty/handler/codec/LengthFieldBasedFrameDecoder.java
+++ b/codec/src/main/java/io/netty/handler/codec/LengthFieldBasedFrameDecoder.java
@@ -15,13 +15,13 @@
  */
 package io.netty.handler.codec;
 
+import java.nio.ByteOrder;
+import java.util.List;
+
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.serialization.ObjectDecoder;
 
-import java.nio.ByteOrder;
-import java.util.List;
-
 /**
  * A decoder that splits the received {@link ByteBuf}s dynamically by the
  * value of the length field in the message.  It is particularly useful when you
@@ -346,6 +346,56 @@ public class LengthFieldBasedFrameDecoder extends ByteToMessageDecoder {
         }
     }
 
+    private void discardingTooLongFrame(ByteBuf in) {
+        long bytesToDiscard = this.bytesToDiscard;
+        int localBytesToDiscard = (int) Math.min(bytesToDiscard, in.readableBytes());
+        in.skipBytes(localBytesToDiscard);
+        bytesToDiscard -= localBytesToDiscard;
+        this.bytesToDiscard = bytesToDiscard;
+
+        failIfNecessary(false);
+    }
+
+    private static void failOnNegativeLengthField(ByteBuf in, long frameLength, int lengthFieldEndOffset) {
+        in.skipBytes(lengthFieldEndOffset);
+        throw new CorruptedFrameException(
+           "negative pre-adjustment length field: " + frameLength);
+    }
+
+    private static void failOnFrameLengthLessThanLengthFieldEndOffset(ByteBuf in,
+                                                                      long frameLength,
+                                                                      int lengthFieldEndOffset) {
+        in.skipBytes(lengthFieldEndOffset);
+        throw new CorruptedFrameException(
+           "Adjusted frame length (" + frameLength + ") is less " +
+              "than lengthFieldEndOffset: " + lengthFieldEndOffset);
+    }
+
+    private void exceededFrameLength(ByteBuf in, long frameLength) {
+        long discard = frameLength - in.readableBytes();
+        tooLongFrameLength = frameLength;
+
+        if (discard < 0) {
+            // buffer contains more bytes then the frameLength so we can discard all now
+            in.skipBytes((int) frameLength);
+        } else {
+            // Enter the discard mode and discard everything received so far.
+            discardingTooLongFrame = true;
+            bytesToDiscard = discard;
+            in.skipBytes(in.readableBytes());
+        }
+        failIfNecessary(true);
+    }
+
+    private static void failOnFrameLengthLessThanInitialBytesToStrip(ByteBuf in,
+                                                                     long frameLength,
+                                                                     int initialBytesToStrip) {
+        in.skipBytes((int) frameLength);
+        throw new CorruptedFrameException(
+           "Adjusted frame length (" + frameLength + ") is less " +
+              "than initialBytesToStrip: " + initialBytesToStrip);
+    }
+
     /**
      * Create a frame out of the {@link ByteBuf} and return it.
      *
@@ -356,13 +406,7 @@ public class LengthFieldBasedFrameDecoder extends ByteToMessageDecoder {
      */
     protected Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception {
         if (discardingTooLongFrame) {
-            long bytesToDiscard = this.bytesToDiscard;
-            int localBytesToDiscard = (int) Math.min(bytesToDiscard, in.readableBytes());
-            in.skipBytes(localBytesToDiscard);
-            bytesToDiscard -= localBytesToDiscard;
-            this.bytesToDiscard = bytesToDiscard;
-
-            failIfNecessary(false);
+            discardingTooLongFrame(in);
         }
 
         if (in.readableBytes() < lengthFieldEndOffset) {
@@ -373,34 +417,17 @@ public class LengthFieldBasedFrameDecoder extends ByteToMessageDecoder {
         long frameLength = getUnadjustedFrameLength(in, actualLengthFieldOffset, lengthFieldLength, byteOrder);
 
         if (frameLength < 0) {
-            in.skipBytes(lengthFieldEndOffset);
-            throw new CorruptedFrameException(
-                    "negative pre-adjustment length field: " + frameLength);
+            failOnNegativeLengthField(in, frameLength, lengthFieldEndOffset);
         }
 
         frameLength += lengthAdjustment + lengthFieldEndOffset;
 
         if (frameLength < lengthFieldEndOffset) {
-            in.skipBytes(lengthFieldEndOffset);
-            throw new CorruptedFrameException(
-                    "Adjusted frame length (" + frameLength + ") is less " +
-                    "than lengthFieldEndOffset: " + lengthFieldEndOffset);
+            failOnFrameLengthLessThanLengthFieldEndOffset(in, frameLength, lengthFieldEndOffset);
         }
 
         if (frameLength > maxFrameLength) {
-            long discard = frameLength - in.readableBytes();
-            tooLongFrameLength = frameLength;
-
-            if (discard < 0) {
-                // buffer contains more bytes then the frameLength so we can discard all now
-                in.skipBytes((int) frameLength);
-            } else {
-                // Enter the discard mode and discard everything received so far.
-                discardingTooLongFrame = true;
-                bytesToDiscard = discard;
-                in.skipBytes(in.readableBytes());
-            }
-            failIfNecessary(true);
+            exceededFrameLength(in, frameLength);
             return null;
         }
 
@@ -411,10 +438,7 @@ public class LengthFieldBasedFrameDecoder extends ByteToMessageDecoder {
         }
 
         if (initialBytesToStrip > frameLengthInt) {
-            in.skipBytes(frameLengthInt);
-            throw new CorruptedFrameException(
-                    "Adjusted frame length (" + frameLength + ") is less " +
-                    "than initialBytesToStrip: " + initialBytesToStrip);
+            failOnFrameLengthLessThanInitialBytesToStrip(in, frameLength, initialBytesToStrip);
         }
         in.skipBytes(initialBytesToStrip);