From d8d3cfd60b7ebb81a9c602308e50f90d192c5d2e Mon Sep 17 00:00:00 2001
From: vibul <vibuli@gmail.com>
Date: Thu, 15 Dec 2011 16:35:01 +1100
Subject: [PATCH] Format source code

---
 .../websocketx/autobahn/WebSocketServer.java  |  14 +-
 .../autobahn/WebSocketServerHandler.java      |   5 +-
 .../websocketx/client/WebSocketCallback.java  |  61 +-
 .../client/WebSocketClientFactory.java        |   7 +-
 .../client/WebSocketClientHandler.java        |   5 +-
 .../websocketx/client/WebSocketException.java |  16 +-
 .../client/WebSocketHttpResponseDecoder.java  |  42 +-
 .../websocketx/server/WebSocketServer.java    |  14 +-
 .../server/WebSocketServerIndexPage.java      | 103 ++--
 .../sslserver/WebSocketSslServer.java         |  16 +-
 .../WebSocketSslServerIndexPage.java          | 103 ++--
 .../WebSocketSslServerPipelineFactory.java    |   8 +-
 .../WebSocketSslServerSslContext.java         |   5 +-
 .../http/websocketx/BinaryWebSocketFrame.java |  70 ++-
 .../http/websocketx/CloseWebSocketFrame.java  |  44 +-
 .../ContinuationWebSocketFrame.java           | 206 ++++---
 .../http/websocketx/PingWebSocketFrame.java   |  70 +--
 .../http/websocketx/PongWebSocketFrame.java   |  68 +--
 .../http/websocketx/TextWebSocketFrame.java   | 178 +++---
 .../codec/http/websocketx/UTF8Exception.java  |   8 +-
 .../codec/http/websocketx/UTF8Output.java     |  80 +--
 .../websocketx/WebSocket00FrameDecoder.java   | 172 +++---
 .../websocketx/WebSocket00FrameEncoder.java   | 121 ++--
 .../websocketx/WebSocket08FrameDecoder.java   | 565 +++++++++---------
 .../websocketx/WebSocket08FrameEncoder.java   | 198 +++---
 .../websocketx/WebSocket13FrameDecoder.java   |  27 +-
 .../websocketx/WebSocket13FrameEncoder.java   |  24 +-
 .../websocketx/WebSocketClientHandshaker.java |  12 +-
 .../WebSocketClientHandshaker00.java          |  19 +-
 .../WebSocketClientHandshaker08.java          |  22 +-
 .../WebSocketClientHandshaker13.java          |  20 +-
 .../WebSocketClientHandshakerFactory.java     |  12 +-
 .../codec/http/websocketx/WebSocketFrame.java |  88 +--
 .../http/websocketx/WebSocketFrameType.java   |   2 +-
 .../WebSocketHandshakeException.java          |  14 +-
 .../websocketx/WebSocketServerHandshaker.java | 268 +++++----
 .../WebSocketServerHandshaker00.java          | 259 ++++----
 .../WebSocketServerHandshaker08.java          |  46 +-
 .../WebSocketServerHandshaker13.java          |  44 +-
 .../WebSocketServerHandshakerFactory.java     |  19 +-
 .../http/websocketx/WebSocketVersion.java     |  15 +-
 41 files changed, 1524 insertions(+), 1546 deletions(-)

diff --git a/src/main/java/org/jboss/netty/example/http/websocketx/autobahn/WebSocketServer.java b/src/main/java/org/jboss/netty/example/http/websocketx/autobahn/WebSocketServer.java
index 8e5a2e357e..5bb3f67b12 100644
--- a/src/main/java/org/jboss/netty/example/http/websocketx/autobahn/WebSocketServer.java
+++ b/src/main/java/org/jboss/netty/example/http/websocketx/autobahn/WebSocketServer.java
@@ -25,8 +25,8 @@ import org.jboss.netty.bootstrap.ServerBootstrap;
 import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory;
 
 /**
- * A Web Socket echo server for running the <a href="http://www.tavendo.de/autobahn/testsuite.html">autobahn</a>
- * test suite
+ * A Web Socket echo server for running the <a href="http://www.tavendo.de/autobahn/testsuite.html">autobahn</a> test
+ * suite
  */
 public class WebSocketServer {
 	public static void main(String[] args) {
@@ -34,19 +34,19 @@ public class WebSocketServer {
 		ch.setLevel(Level.FINE);
 		Logger.getLogger("").addHandler(ch);
 		Logger.getLogger("").setLevel(Level.FINE);
-		
+
 		// Configure the server.
 		ServerBootstrap bootstrap = new ServerBootstrap(new NioServerSocketChannelFactory(
 				Executors.newCachedThreadPool(), Executors.newCachedThreadPool()));
-		
-		//bootstrap.setOption("child.tcpNoDelay", true);
-		
+
+		// bootstrap.setOption("child.tcpNoDelay", true);
+
 		// Set up the event pipeline factory.
 		bootstrap.setPipelineFactory(new WebSocketServerPipelineFactory());
 
 		// Bind and start to accept incoming connections.
 		bootstrap.bind(new InetSocketAddress(9000));
-		
+
 		System.out.println("Web Socket Server started on localhost:9000.");
 	}
 }
diff --git a/src/main/java/org/jboss/netty/example/http/websocketx/autobahn/WebSocketServerHandler.java b/src/main/java/org/jboss/netty/example/http/websocketx/autobahn/WebSocketServerHandler.java
index 8a3b9620cf..dd6bd9b002 100644
--- a/src/main/java/org/jboss/netty/example/http/websocketx/autobahn/WebSocketServerHandler.java
+++ b/src/main/java/org/jboss/netty/example/http/websocketx/autobahn/WebSocketServerHandler.java
@@ -90,8 +90,9 @@ public class WebSocketServerHandler extends SimpleChannelUpstreamHandler {
 			ctx.getChannel().write(
 					new PongWebSocketFrame(frame.isFinalFragment(), frame.getRsv(), frame.getBinaryData()));
 		} else if (frame instanceof TextWebSocketFrame) {
-			//String text = ((TextWebSocketFrame) frame).getText();
-			ctx.getChannel().write(new TextWebSocketFrame(frame.isFinalFragment(), frame.getRsv(), frame.getBinaryData()));
+			// String text = ((TextWebSocketFrame) frame).getText();
+			ctx.getChannel().write(
+					new TextWebSocketFrame(frame.isFinalFragment(), frame.getRsv(), frame.getBinaryData()));
 		} else if (frame instanceof BinaryWebSocketFrame) {
 			ctx.getChannel().write(
 					new BinaryWebSocketFrame(frame.isFinalFragment(), frame.getRsv(), frame.getBinaryData()));
diff --git a/src/main/java/org/jboss/netty/example/http/websocketx/client/WebSocketCallback.java b/src/main/java/org/jboss/netty/example/http/websocketx/client/WebSocketCallback.java
index 5953c73e68..24ece03b93 100644
--- a/src/main/java/org/jboss/netty/example/http/websocketx/client/WebSocketCallback.java
+++ b/src/main/java/org/jboss/netty/example/http/websocketx/client/WebSocketCallback.java
@@ -24,7 +24,6 @@ package org.jboss.netty.example.http.websocketx.client;
 
 import org.jboss.netty.handler.codec.http.websocketx.WebSocketFrame;
 
-
 /**
  * Copied from https://github.com/cgbystrom/netty-tools
  * 
@@ -32,37 +31,37 @@ import org.jboss.netty.handler.codec.http.websocketx.WebSocketFrame;
  */
 public interface WebSocketCallback {
 
-    /**
-     * Called when the client is connected to the server
-     * 
-     * @param client
-     *            Current client used to connect
-     */
-    void onConnect(WebSocketClient client);
+	/**
+	 * Called when the client is connected to the server
+	 * 
+	 * @param client
+	 *            Current client used to connect
+	 */
+	void onConnect(WebSocketClient client);
 
-    /**
-     * Called when the client got disconnected from the server.
-     * 
-     * @param client
-     *            Current client that was disconnected
-     */
-    void onDisconnect(WebSocketClient client);
+	/**
+	 * Called when the client got disconnected from the server.
+	 * 
+	 * @param client
+	 *            Current client that was disconnected
+	 */
+	void onDisconnect(WebSocketClient client);
 
-    /**
-     * Called when a message arrives from the server.
-     * 
-     * @param client
-     *            Current client connected
-     * @param frame
-     *            Data received from server
-     */
-    void onMessage(WebSocketClient client, WebSocketFrame frame);
+	/**
+	 * Called when a message arrives from the server.
+	 * 
+	 * @param client
+	 *            Current client connected
+	 * @param frame
+	 *            Data received from server
+	 */
+	void onMessage(WebSocketClient client, WebSocketFrame frame);
 
-    /**
-     * Called when an unhandled errors occurs.
-     * 
-     * @param t
-     *            The causing error
-     */
-    void onError(Throwable t);
+	/**
+	 * Called when an unhandled errors occurs.
+	 * 
+	 * @param t
+	 *            The causing error
+	 */
+	void onError(Throwable t);
 }
diff --git a/src/main/java/org/jboss/netty/example/http/websocketx/client/WebSocketClientFactory.java b/src/main/java/org/jboss/netty/example/http/websocketx/client/WebSocketClientFactory.java
index 73184e3566..ef00c4a3d6 100644
--- a/src/main/java/org/jboss/netty/example/http/websocketx/client/WebSocketClientFactory.java
+++ b/src/main/java/org/jboss/netty/example/http/websocketx/client/WebSocketClientFactory.java
@@ -38,8 +38,8 @@ import java.util.concurrent.Executors;
 /**
  * Copied from https://github.com/cgbystrom/netty-tools
  * 
- * A factory for creating WebSocket clients. The entry point for creating and
- * connecting a client. Can and should be used to create multiple instances.
+ * A factory for creating WebSocket clients. The entry point for creating and connecting a client. Can and should be
+ * used to create multiple instances.
  */
 public class WebSocketClientFactory {
 
@@ -57,8 +57,7 @@ public class WebSocketClientFactory {
 	 *            Callback interface to receive events
 	 * @param customHeaders
 	 *            Map of custom headers to add to the client request
-	 * @return A WebSocket client. Call {@link WebSocketClient#connect()} to
-	 *         connect.
+	 * @return A WebSocket client. Call {@link WebSocketClient#connect()} to connect.
 	 */
 	public WebSocketClient newClient(final URI url, final WebSocketVersion version, final WebSocketCallback callback,
 			final Map<String, String> customHeaders) {
diff --git a/src/main/java/org/jboss/netty/example/http/websocketx/client/WebSocketClientHandler.java b/src/main/java/org/jboss/netty/example/http/websocketx/client/WebSocketClientHandler.java
index 61ba90d7c7..0fb396cc4a 100644
--- a/src/main/java/org/jboss/netty/example/http/websocketx/client/WebSocketClientHandler.java
+++ b/src/main/java/org/jboss/netty/example/http/websocketx/client/WebSocketClientHandler.java
@@ -44,9 +44,8 @@ import org.jboss.netty.util.CharsetUtil;
 /**
  * Copied from https://github.com/cgbystrom/netty-tools
  * 
- * Handles socket communication for a connected WebSocket client Not intended
- * for end-users. Please use {@link WebSocketClient} or
- * {@link WebSocketCallback} for controlling your client.
+ * Handles socket communication for a connected WebSocket client Not intended for end-users. Please use
+ * {@link WebSocketClient} or {@link WebSocketCallback} for controlling your client.
  */
 public class WebSocketClientHandler extends SimpleChannelUpstreamHandler implements WebSocketClient {
 
diff --git a/src/main/java/org/jboss/netty/example/http/websocketx/client/WebSocketException.java b/src/main/java/org/jboss/netty/example/http/websocketx/client/WebSocketException.java
index 3f7280bc4d..91762218fa 100644
--- a/src/main/java/org/jboss/netty/example/http/websocketx/client/WebSocketException.java
+++ b/src/main/java/org/jboss/netty/example/http/websocketx/client/WebSocketException.java
@@ -30,15 +30,15 @@ import java.io.IOException;
  */
 public class WebSocketException extends IOException {
 
-    /**
+	/**
  */
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public WebSocketException(String s) {
-        super(s);
-    }
+	public WebSocketException(String s) {
+		super(s);
+	}
 
-    public WebSocketException(String s, Throwable throwable) {
-        super(s, throwable);
-    }
+	public WebSocketException(String s, Throwable throwable) {
+		super(s, throwable);
+	}
 }
\ No newline at end of file
diff --git a/src/main/java/org/jboss/netty/example/http/websocketx/client/WebSocketHttpResponseDecoder.java b/src/main/java/org/jboss/netty/example/http/websocketx/client/WebSocketHttpResponseDecoder.java
index 745b9126d6..21cef9a313 100644
--- a/src/main/java/org/jboss/netty/example/http/websocketx/client/WebSocketHttpResponseDecoder.java
+++ b/src/main/java/org/jboss/netty/example/http/websocketx/client/WebSocketHttpResponseDecoder.java
@@ -25,27 +25,27 @@ import org.jboss.netty.handler.codec.http.HttpResponseDecoder;
  */
 public class WebSocketHttpResponseDecoder extends HttpResponseDecoder {
 
-    @Override
-    protected boolean isContentAlwaysEmpty(HttpMessage msg) {
-        if (msg instanceof HttpResponse) {
-            HttpResponse res = (HttpResponse) msg;
-            int code = res.getStatus().getCode();
+	@Override
+	protected boolean isContentAlwaysEmpty(HttpMessage msg) {
+		if (msg instanceof HttpResponse) {
+			HttpResponse res = (HttpResponse) msg;
+			int code = res.getStatus().getCode();
 
-            // FIX force reading of protocol upgrade challenge data into the content buffer
-            if (code == 101) {
-                return false;
-            }
+			// FIX force reading of protocol upgrade challenge data into the content buffer
+			if (code == 101) {
+				return false;
+			}
 
-            if (code < 200) {
-                return true;
-            }
-            switch (code) {
-                case 204:
-                case 205:
-                case 304:
-                    return true;
-            }
-        }
-        return false;
-    }
+			if (code < 200) {
+				return true;
+			}
+			switch (code) {
+			case 204:
+			case 205:
+			case 304:
+				return true;
+			}
+		}
+		return false;
+	}
 }
diff --git a/src/main/java/org/jboss/netty/example/http/websocketx/server/WebSocketServer.java b/src/main/java/org/jboss/netty/example/http/websocketx/server/WebSocketServer.java
index 81a85a5930..e08333ac6e 100644
--- a/src/main/java/org/jboss/netty/example/http/websocketx/server/WebSocketServer.java
+++ b/src/main/java/org/jboss/netty/example/http/websocketx/server/WebSocketServer.java
@@ -29,11 +29,10 @@ import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory;
  * 
  * http://localhost:8080/websocket
  * 
- * Open your browser at http://localhost:8080/, then the demo page will be
- * loaded and a Web Socket connection will be made automatically.
+ * Open your browser at http://localhost:8080/, then the demo page will be loaded and a Web Socket connection will be
+ * made automatically.
  * 
- * This server illustrates support for the different web socket specification
- * versions and will work with:
+ * This server illustrates support for the different web socket specification versions and will work with:
  * 
  * <ul>
  * <li>Safari 5+ (draft-ietf-hybi-thewebsocketprotocol-00)
@@ -52,7 +51,7 @@ public class WebSocketServer {
 		ch.setLevel(Level.FINE);
 		Logger.getLogger("").addHandler(ch);
 		Logger.getLogger("").setLevel(Level.FINE);
-		
+
 		// Configure the server.
 		ServerBootstrap bootstrap = new ServerBootstrap(new NioServerSocketChannelFactory(
 				Executors.newCachedThreadPool(), Executors.newCachedThreadPool()));
@@ -62,7 +61,8 @@ public class WebSocketServer {
 
 		// Bind and start to accept incoming connections.
 		bootstrap.bind(new InetSocketAddress(8080));
-		
-		System.out.println("Web Socket Server started on 8080. Open your browser and navigate to http://localhost:8080/");
+
+		System.out
+				.println("Web Socket Server started on 8080. Open your browser and navigate to http://localhost:8080/");
 	}
 }
diff --git a/src/main/java/org/jboss/netty/example/http/websocketx/server/WebSocketServerIndexPage.java b/src/main/java/org/jboss/netty/example/http/websocketx/server/WebSocketServerIndexPage.java
index bd1464ac75..ceffd8003f 100644
--- a/src/main/java/org/jboss/netty/example/http/websocketx/server/WebSocketServerIndexPage.java
+++ b/src/main/java/org/jboss/netty/example/http/websocketx/server/WebSocketServerIndexPage.java
@@ -19,49 +19,74 @@ import org.jboss.netty.buffer.ChannelBuffer;
 import org.jboss.netty.buffer.ChannelBuffers;
 import org.jboss.netty.util.CharsetUtil;
 
-
 /**
  * Generates the demo HTML page which is served at http://localhost:8080/
  */
 public class WebSocketServerIndexPage {
 
-    private static final String NEWLINE = "\r\n";
+	private static final String NEWLINE = "\r\n";
 
-    public static ChannelBuffer getContent(String webSocketLocation) {
-        return ChannelBuffers.copiedBuffer(
-        "<html><head><title>Web Socket Test</title></head>" + NEWLINE +
-        "<body>" + NEWLINE +
-        "<script type=\"text/javascript\">" + NEWLINE +
-        "var socket;" + NEWLINE +
-        "if (!window.WebSocket) {" + NEWLINE +
-        "  window.WebSocket = window.MozWebSocket;" + NEWLINE +
-        "}" + NEWLINE +        
-        "if (window.WebSocket) {" + NEWLINE +
-        "  socket = new WebSocket(\"" + webSocketLocation + "\");" + NEWLINE +
-        "  socket.onmessage = function(event) { var ta = document.getElementById('responseText'); ta.value = ta.value + '\\n' + event.data };" + NEWLINE +
-        "  socket.onopen = function(event) { var ta = document.getElementById('responseText'); ta.value = \"Web Socket opened!\"; };" + NEWLINE +
-        "  socket.onclose = function(event) { var ta = document.getElementById('responseText'); ta.value = ta.value + \"Web Socket closed\"; };" + NEWLINE +
-        "} else {" + NEWLINE +
-        "  alert(\"Your browser does not support Web Socket.\");" + NEWLINE +
-        "}" + NEWLINE +
-        NEWLINE +
-        "function send(message) {" + NEWLINE +
-        "  if (!window.WebSocket) { return; }" + NEWLINE +
-        "  if (socket.readyState == WebSocket.OPEN) {" + NEWLINE +
-        "    socket.send(message);" + NEWLINE +
-        "  } else {" + NEWLINE +
-        "    alert(\"The socket is not open.\");" + NEWLINE +
-        "  }" + NEWLINE +
-        "}" + NEWLINE +
-        "</script>" + NEWLINE +
-        "<form onsubmit=\"return false;\">" + NEWLINE +
-        "<input type=\"text\" name=\"message\" value=\"Hello, World!\"/>" +
-        "<input type=\"button\" value=\"Send Web Socket Data\" onclick=\"send(this.form.message.value)\" />" + NEWLINE +
-        "<h3>Output</h3>" + NEWLINE +
-        "<textarea id=\"responseText\" style=\"width: 500px; height:300px;\"></textarea>" + NEWLINE +
-        "</form>" + NEWLINE +
-        "</body>" + NEWLINE +
-        "</html>" + NEWLINE,
-        CharsetUtil.US_ASCII);
-    }
+	public static ChannelBuffer getContent(String webSocketLocation) {
+		return ChannelBuffers
+				.copiedBuffer(
+						"<html><head><title>Web Socket Test</title></head>"
+								+ NEWLINE
+								+ "<body>"
+								+ NEWLINE
+								+ "<script type=\"text/javascript\">"
+								+ NEWLINE
+								+ "var socket;"
+								+ NEWLINE
+								+ "if (!window.WebSocket) {"
+								+ NEWLINE
+								+ "  window.WebSocket = window.MozWebSocket;"
+								+ NEWLINE
+								+ "}"
+								+ NEWLINE
+								+ "if (window.WebSocket) {"
+								+ NEWLINE
+								+ "  socket = new WebSocket(\""
+								+ webSocketLocation
+								+ "\");"
+								+ NEWLINE
+								+ "  socket.onmessage = function(event) { var ta = document.getElementById('responseText'); ta.value = ta.value + '\\n' + event.data };"
+								+ NEWLINE
+								+ "  socket.onopen = function(event) { var ta = document.getElementById('responseText'); ta.value = \"Web Socket opened!\"; };"
+								+ NEWLINE
+								+ "  socket.onclose = function(event) { var ta = document.getElementById('responseText'); ta.value = ta.value + \"Web Socket closed\"; };"
+								+ NEWLINE
+								+ "} else {"
+								+ NEWLINE
+								+ "  alert(\"Your browser does not support Web Socket.\");"
+								+ NEWLINE
+								+ "}"
+								+ NEWLINE
+								+ NEWLINE
+								+ "function send(message) {"
+								+ NEWLINE
+								+ "  if (!window.WebSocket) { return; }"
+								+ NEWLINE
+								+ "  if (socket.readyState == WebSocket.OPEN) {"
+								+ NEWLINE
+								+ "    socket.send(message);"
+								+ NEWLINE
+								+ "  } else {"
+								+ NEWLINE
+								+ "    alert(\"The socket is not open.\");"
+								+ NEWLINE
+								+ "  }"
+								+ NEWLINE
+								+ "}"
+								+ NEWLINE
+								+ "</script>"
+								+ NEWLINE
+								+ "<form onsubmit=\"return false;\">"
+								+ NEWLINE
+								+ "<input type=\"text\" name=\"message\" value=\"Hello, World!\"/>"
+								+ "<input type=\"button\" value=\"Send Web Socket Data\" onclick=\"send(this.form.message.value)\" />"
+								+ NEWLINE + "<h3>Output</h3>" + NEWLINE
+								+ "<textarea id=\"responseText\" style=\"width: 500px; height:300px;\"></textarea>"
+								+ NEWLINE + "</form>" + NEWLINE + "</body>" + NEWLINE + "</html>" + NEWLINE,
+						CharsetUtil.US_ASCII);
+	}
 }
diff --git a/src/main/java/org/jboss/netty/example/http/websocketx/sslserver/WebSocketSslServer.java b/src/main/java/org/jboss/netty/example/http/websocketx/sslserver/WebSocketSslServer.java
index c3d00504a0..3dc154e3c1 100644
--- a/src/main/java/org/jboss/netty/example/http/websocketx/sslserver/WebSocketSslServer.java
+++ b/src/main/java/org/jboss/netty/example/http/websocketx/sslserver/WebSocketSslServer.java
@@ -29,11 +29,10 @@ import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory;
  * 
  * https://localhost:8081/websocket
  * 
- * Open your browser at https://localhost:8081/, then the demo page will be
- * loaded and a Web Socket connection will be made automatically.
+ * Open your browser at https://localhost:8081/, then the demo page will be loaded and a Web Socket connection will be
+ * made automatically.
  * 
- * This server illustrates support for the different web socket specification
- * versions and will work with:
+ * This server illustrates support for the different web socket specification versions and will work with:
  * 
  * <ul>
  * <li>Safari 5+ (draft-ietf-hybi-thewebsocketprotocol-00)
@@ -52,13 +51,13 @@ public class WebSocketSslServer {
 		ch.setLevel(Level.FINE);
 		Logger.getLogger("").addHandler(ch);
 		Logger.getLogger("").setLevel(Level.FINE);
-		
+
 		String keyStoreFilePath = System.getProperty("keystore.file.path");
 		if (keyStoreFilePath == null || keyStoreFilePath.isEmpty()) {
 			System.out.println("ERROR: System property keystore.file.path not set. Exiting now!");
 			System.exit(1);
 		}
-		
+
 		String keyStoreFilePassword = System.getProperty("keystore.file.password");
 		if (keyStoreFilePassword == null || keyStoreFilePassword.isEmpty()) {
 			System.out.println("ERROR: System property keystore.file.password not set. Exiting now!");
@@ -74,7 +73,8 @@ public class WebSocketSslServer {
 
 		// Bind and start to accept incoming connections.
 		bootstrap.bind(new InetSocketAddress(8081));
-		
-		System.out.println("Web Socket Server started on 8081. Open your browser and navigate to https://localhost:8081/");
+
+		System.out
+				.println("Web Socket Server started on 8081. Open your browser and navigate to https://localhost:8081/");
 	}
 }
diff --git a/src/main/java/org/jboss/netty/example/http/websocketx/sslserver/WebSocketSslServerIndexPage.java b/src/main/java/org/jboss/netty/example/http/websocketx/sslserver/WebSocketSslServerIndexPage.java
index 7d06440874..60779335b0 100644
--- a/src/main/java/org/jboss/netty/example/http/websocketx/sslserver/WebSocketSslServerIndexPage.java
+++ b/src/main/java/org/jboss/netty/example/http/websocketx/sslserver/WebSocketSslServerIndexPage.java
@@ -19,49 +19,74 @@ import org.jboss.netty.buffer.ChannelBuffer;
 import org.jboss.netty.buffer.ChannelBuffers;
 import org.jboss.netty.util.CharsetUtil;
 
-
 /**
  * Generates the demo HTML page which is served at http://localhost:8080/
  */
 public class WebSocketSslServerIndexPage {
 
-    private static final String NEWLINE = "\r\n";
+	private static final String NEWLINE = "\r\n";
 
-    public static ChannelBuffer getContent(String webSocketLocation) {
-        return ChannelBuffers.copiedBuffer(
-        "<html><head><title>Web Socket Test</title></head>" + NEWLINE +
-        "<body>" + NEWLINE +
-        "<script type=\"text/javascript\">" + NEWLINE +
-        "var socket;" + NEWLINE +
-        "if (!window.WebSocket) {" + NEWLINE +
-        "  window.WebSocket = window.MozWebSocket;" + NEWLINE +
-        "}" + NEWLINE +        
-        "if (window.WebSocket) {" + NEWLINE +
-        "  socket = new WebSocket(\"" + webSocketLocation + "\");" + NEWLINE +
-        "  socket.onmessage = function(event) { var ta = document.getElementById('responseText'); ta.value = ta.value + '\\n' + event.data };" + NEWLINE +
-        "  socket.onopen = function(event) { var ta = document.getElementById('responseText'); ta.value = \"Web Socket opened!\"; };" + NEWLINE +
-        "  socket.onclose = function(event) { var ta = document.getElementById('responseText'); ta.value = ta.value + \"Web Socket closed\"; };" + NEWLINE +
-        "} else {" + NEWLINE +
-        "  alert(\"Your browser does not support Web Socket.\");" + NEWLINE +
-        "}" + NEWLINE +
-        NEWLINE +
-        "function send(message) {" + NEWLINE +
-        "  if (!window.WebSocket) { return; }" + NEWLINE +
-        "  if (socket.readyState == WebSocket.OPEN) {" + NEWLINE +
-        "    socket.send(message);" + NEWLINE +
-        "  } else {" + NEWLINE +
-        "    alert(\"The socket is not open.\");" + NEWLINE +
-        "  }" + NEWLINE +
-        "}" + NEWLINE +
-        "</script>" + NEWLINE +
-        "<form onsubmit=\"return false;\">" + NEWLINE +
-        "<input type=\"text\" name=\"message\" value=\"Hello, World!\"/>" +
-        "<input type=\"button\" value=\"Send Web Socket Data\" onclick=\"send(this.form.message.value)\" />" + NEWLINE +
-        "<h3>Output</h3>" + NEWLINE +
-        "<textarea id=\"responseText\" style=\"width: 500px; height:300px;\"></textarea>" + NEWLINE +
-        "</form>" + NEWLINE +
-        "</body>" + NEWLINE +
-        "</html>" + NEWLINE,
-        CharsetUtil.US_ASCII);
-    }
+	public static ChannelBuffer getContent(String webSocketLocation) {
+		return ChannelBuffers
+				.copiedBuffer(
+						"<html><head><title>Web Socket Test</title></head>"
+								+ NEWLINE
+								+ "<body>"
+								+ NEWLINE
+								+ "<script type=\"text/javascript\">"
+								+ NEWLINE
+								+ "var socket;"
+								+ NEWLINE
+								+ "if (!window.WebSocket) {"
+								+ NEWLINE
+								+ "  window.WebSocket = window.MozWebSocket;"
+								+ NEWLINE
+								+ "}"
+								+ NEWLINE
+								+ "if (window.WebSocket) {"
+								+ NEWLINE
+								+ "  socket = new WebSocket(\""
+								+ webSocketLocation
+								+ "\");"
+								+ NEWLINE
+								+ "  socket.onmessage = function(event) { var ta = document.getElementById('responseText'); ta.value = ta.value + '\\n' + event.data };"
+								+ NEWLINE
+								+ "  socket.onopen = function(event) { var ta = document.getElementById('responseText'); ta.value = \"Web Socket opened!\"; };"
+								+ NEWLINE
+								+ "  socket.onclose = function(event) { var ta = document.getElementById('responseText'); ta.value = ta.value + \"Web Socket closed\"; };"
+								+ NEWLINE
+								+ "} else {"
+								+ NEWLINE
+								+ "  alert(\"Your browser does not support Web Socket.\");"
+								+ NEWLINE
+								+ "}"
+								+ NEWLINE
+								+ NEWLINE
+								+ "function send(message) {"
+								+ NEWLINE
+								+ "  if (!window.WebSocket) { return; }"
+								+ NEWLINE
+								+ "  if (socket.readyState == WebSocket.OPEN) {"
+								+ NEWLINE
+								+ "    socket.send(message);"
+								+ NEWLINE
+								+ "  } else {"
+								+ NEWLINE
+								+ "    alert(\"The socket is not open.\");"
+								+ NEWLINE
+								+ "  }"
+								+ NEWLINE
+								+ "}"
+								+ NEWLINE
+								+ "</script>"
+								+ NEWLINE
+								+ "<form onsubmit=\"return false;\">"
+								+ NEWLINE
+								+ "<input type=\"text\" name=\"message\" value=\"Hello, World!\"/>"
+								+ "<input type=\"button\" value=\"Send Web Socket Data\" onclick=\"send(this.form.message.value)\" />"
+								+ NEWLINE + "<h3>Output</h3>" + NEWLINE
+								+ "<textarea id=\"responseText\" style=\"width: 500px; height:300px;\"></textarea>"
+								+ NEWLINE + "</form>" + NEWLINE + "</body>" + NEWLINE + "</html>" + NEWLINE,
+						CharsetUtil.US_ASCII);
+	}
 }
diff --git a/src/main/java/org/jboss/netty/example/http/websocketx/sslserver/WebSocketSslServerPipelineFactory.java b/src/main/java/org/jboss/netty/example/http/websocketx/sslserver/WebSocketSslServerPipelineFactory.java
index fb512945cb..79e8f1c49c 100644
--- a/src/main/java/org/jboss/netty/example/http/websocketx/sslserver/WebSocketSslServerPipelineFactory.java
+++ b/src/main/java/org/jboss/netty/example/http/websocketx/sslserver/WebSocketSslServerPipelineFactory.java
@@ -32,10 +32,10 @@ public class WebSocketSslServerPipelineFactory implements ChannelPipelineFactory
 	public ChannelPipeline getPipeline() throws Exception {
 		// Create a default pipeline implementation.
 		ChannelPipeline pipeline = pipeline();
-		
-        SSLEngine engine = WebSocketSslServerSslContext.getInstance().getServerContext().createSSLEngine();
-        engine.setUseClientMode(false);
-        pipeline.addLast("ssl", new SslHandler(engine));
+
+		SSLEngine engine = WebSocketSslServerSslContext.getInstance().getServerContext().createSSLEngine();
+		engine.setUseClientMode(false);
+		pipeline.addLast("ssl", new SslHandler(engine));
 
 		pipeline.addLast("decoder", new HttpRequestDecoder());
 		pipeline.addLast("aggregator", new HttpChunkAggregator(65536));
diff --git a/src/main/java/org/jboss/netty/example/http/websocketx/sslserver/WebSocketSslServerSslContext.java b/src/main/java/org/jboss/netty/example/http/websocketx/sslserver/WebSocketSslServerSslContext.java
index c0464141fa..ab440adaee 100644
--- a/src/main/java/org/jboss/netty/example/http/websocketx/sslserver/WebSocketSslServerSslContext.java
+++ b/src/main/java/org/jboss/netty/example/http/websocketx/sslserver/WebSocketSslServerSslContext.java
@@ -42,9 +42,8 @@ public class WebSocketSslServerSslContext {
 	}
 
 	/**
-	 * SingletonHolder is loaded on the first execution of
-	 * Singleton.getInstance() or the first access to SingletonHolder.INSTANCE,
-	 * not before.
+	 * SingletonHolder is loaded on the first execution of Singleton.getInstance() or the first access to
+	 * SingletonHolder.INSTANCE, not before.
 	 * 
 	 * See http://en.wikipedia.org/wiki/Singleton_pattern
 	 */
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/BinaryWebSocketFrame.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/BinaryWebSocketFrame.java
index d659ae5039..d8fdf20aa6 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/BinaryWebSocketFrame.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/BinaryWebSocketFrame.java
@@ -23,44 +23,42 @@ import org.jboss.netty.buffer.ChannelBuffers;
  */
 public class BinaryWebSocketFrame extends WebSocketFrame {
 
-    /**
-     * Creates a new empty binary frame.
-     */
-    public BinaryWebSocketFrame() {
-        this.setBinaryData(ChannelBuffers.EMPTY_BUFFER);
-    }
+	/**
+	 * Creates a new empty binary frame.
+	 */
+	public BinaryWebSocketFrame() {
+		this.setBinaryData(ChannelBuffers.EMPTY_BUFFER);
+	}
 
-    /**
-     * Creates a new binary frame with the specified binary data. The final
-     * fragment flag is set to true.
-     * 
-     * @param binaryData
-     *            the content of the frame.
-     */
-    public BinaryWebSocketFrame(ChannelBuffer binaryData) {
-        this.setBinaryData(binaryData);
-    }
+	/**
+	 * Creates a new binary frame with the specified binary data. The final fragment flag is set to true.
+	 * 
+	 * @param binaryData
+	 *            the content of the frame.
+	 */
+	public BinaryWebSocketFrame(ChannelBuffer binaryData) {
+		this.setBinaryData(binaryData);
+	}
 
-    /**
-     * Creates a new binary frame with the specified binary data and the final
-     * fragment flag.
-     * 
-     * @param finalFragment
-     *            flag indicating if this frame is the final fragment
-     * @param rsv
-     *            reserved bits used for protocol extensions
-     * @param binaryData
-     *            the content of the frame.
-     */
-    public BinaryWebSocketFrame(boolean finalFragment, int rsv, ChannelBuffer binaryData) {
-        this.setFinalFragment(finalFragment);
-        this.setRsv(rsv);
-        this.setBinaryData(binaryData);
-    }
+	/**
+	 * Creates a new binary frame with the specified binary data and the final fragment flag.
+	 * 
+	 * @param finalFragment
+	 *            flag indicating if this frame is the final fragment
+	 * @param rsv
+	 *            reserved bits used for protocol extensions
+	 * @param binaryData
+	 *            the content of the frame.
+	 */
+	public BinaryWebSocketFrame(boolean finalFragment, int rsv, ChannelBuffer binaryData) {
+		this.setFinalFragment(finalFragment);
+		this.setRsv(rsv);
+		this.setBinaryData(binaryData);
+	}
 
-    @Override
-    public String toString() {
-        return getClass().getSimpleName() + "(data: " + getBinaryData() + ')';
-    }
+	@Override
+	public String toString() {
+		return getClass().getSimpleName() + "(data: " + getBinaryData() + ')';
+	}
 
 }
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/CloseWebSocketFrame.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/CloseWebSocketFrame.java
index 1bf50dcecc..9444e8f199 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/CloseWebSocketFrame.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/CloseWebSocketFrame.java
@@ -22,28 +22,28 @@ import org.jboss.netty.buffer.ChannelBuffers;
  */
 public class CloseWebSocketFrame extends WebSocketFrame {
 
-    /**
-     * Creates a new empty close frame.
-     */
-    public CloseWebSocketFrame() {
-        this.setBinaryData(ChannelBuffers.EMPTY_BUFFER);
-    }
+	/**
+	 * Creates a new empty close frame.
+	 */
+	public CloseWebSocketFrame() {
+		this.setBinaryData(ChannelBuffers.EMPTY_BUFFER);
+	}
 
-    /**
-     * Creates a new close frame
-     * 
-     * @param finalFragment
-     *            flag indicating if this frame is the final fragment
-     * @param rsv
-     *            reserved bits used for protocol extensions
-     */
-    public CloseWebSocketFrame(boolean finalFragment, int rsv) {
-        this.setFinalFragment(finalFragment);
-        this.setRsv(rsv);
-    }
+	/**
+	 * Creates a new close frame
+	 * 
+	 * @param finalFragment
+	 *            flag indicating if this frame is the final fragment
+	 * @param rsv
+	 *            reserved bits used for protocol extensions
+	 */
+	public CloseWebSocketFrame(boolean finalFragment, int rsv) {
+		this.setFinalFragment(finalFragment);
+		this.setRsv(rsv);
+	}
 
-    @Override
-    public String toString() {
-        return getClass().getSimpleName();
-    }
+	@Override
+	public String toString() {
+		return getClass().getSimpleName();
+	}
 }
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/ContinuationWebSocketFrame.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/ContinuationWebSocketFrame.java
index b154f5f230..ea9cd884a3 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/ContinuationWebSocketFrame.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/ContinuationWebSocketFrame.java
@@ -20,123 +20,119 @@ import org.jboss.netty.buffer.ChannelBuffers;
 import org.jboss.netty.util.CharsetUtil;
 
 /**
- * Web Socket continuation frame containing continuation text or binary data.
- * This is used for fragmented messages where the contents of a messages is
- * contained more than 1 frame.
+ * Web Socket continuation frame containing continuation text or binary data. This is used for fragmented messages where
+ * the contents of a messages is contained more than 1 frame.
  */
 public class ContinuationWebSocketFrame extends WebSocketFrame {
 
-    private String aggregatedText = null;
+	private String aggregatedText = null;
 
-    /**
-     * Creates a new empty continuation frame.
-     */
-    public ContinuationWebSocketFrame() {
-        this.setBinaryData(ChannelBuffers.EMPTY_BUFFER);
-    }
+	/**
+	 * Creates a new empty continuation frame.
+	 */
+	public ContinuationWebSocketFrame() {
+		this.setBinaryData(ChannelBuffers.EMPTY_BUFFER);
+	}
 
-    /**
-     * Creates a new continuation frame with the specified binary data. The
-     * final fragment flag is set to true.
-     * 
-     * @param binaryData
-     *            the content of the frame.
-     */
-    public ContinuationWebSocketFrame(ChannelBuffer binaryData) {
-        this.setBinaryData(binaryData);
-    }
+	/**
+	 * Creates a new continuation frame with the specified binary data. The final fragment flag is set to true.
+	 * 
+	 * @param binaryData
+	 *            the content of the frame.
+	 */
+	public ContinuationWebSocketFrame(ChannelBuffer binaryData) {
+		this.setBinaryData(binaryData);
+	}
 
-    /**
-     * Creates a new continuation frame with the specified binary data
-     * 
-     * @param finalFragment
-     *            flag indicating if this frame is the final fragment
-     * @param rsv
-     *            reserved bits used for protocol extensions
-     * @param binaryData
-     *            the content of the frame.
-     */
-    public ContinuationWebSocketFrame(boolean finalFragment, int rsv, ChannelBuffer binaryData) {
-        this.setFinalFragment(finalFragment);
-        this.setRsv(rsv);
-        this.setBinaryData(binaryData);
-    }
+	/**
+	 * Creates a new continuation frame with the specified binary data
+	 * 
+	 * @param finalFragment
+	 *            flag indicating if this frame is the final fragment
+	 * @param rsv
+	 *            reserved bits used for protocol extensions
+	 * @param binaryData
+	 *            the content of the frame.
+	 */
+	public ContinuationWebSocketFrame(boolean finalFragment, int rsv, ChannelBuffer binaryData) {
+		this.setFinalFragment(finalFragment);
+		this.setRsv(rsv);
+		this.setBinaryData(binaryData);
+	}
 
-    /**
-     * Creates a new continuation frame with the specified binary data
-     * 
-     * @param finalFragment
-     *            flag indicating if this frame is the final fragment
-     * @param rsv
-     *            reserved bits used for protocol extensions
-     * @param binaryData
-     *            the content of the frame.
-     * @param aggregatedText
-     *            Aggregated text set by decoder on the final continuation frame
-     *            of a fragmented text message
-     */
-    public ContinuationWebSocketFrame(boolean finalFragment, int rsv, ChannelBuffer binaryData, String aggregatedText) {
-        this.setFinalFragment(finalFragment);
-        this.setRsv(rsv);
-        this.setBinaryData(binaryData);
-        this.aggregatedText = aggregatedText;
-    }
+	/**
+	 * Creates a new continuation frame with the specified binary data
+	 * 
+	 * @param finalFragment
+	 *            flag indicating if this frame is the final fragment
+	 * @param rsv
+	 *            reserved bits used for protocol extensions
+	 * @param binaryData
+	 *            the content of the frame.
+	 * @param aggregatedText
+	 *            Aggregated text set by decoder on the final continuation frame of a fragmented text message
+	 */
+	public ContinuationWebSocketFrame(boolean finalFragment, int rsv, ChannelBuffer binaryData, String aggregatedText) {
+		this.setFinalFragment(finalFragment);
+		this.setRsv(rsv);
+		this.setBinaryData(binaryData);
+		this.aggregatedText = aggregatedText;
+	}
 
-    /**
-     * Creates a new continuation frame with the specified text data
-     * 
-     * @param finalFragment
-     *            flag indicating if this frame is the final fragment
-     * @param rsv
-     *            reserved bits used for protocol extensions
-     * @param text
-     *            text content of the frame.
-     */
-    public ContinuationWebSocketFrame(boolean finalFragment, int rsv, String text) {
-        this.setFinalFragment(finalFragment);
-        this.setRsv(rsv);
-        this.setText(text);
-    }
+	/**
+	 * Creates a new continuation frame with the specified text data
+	 * 
+	 * @param finalFragment
+	 *            flag indicating if this frame is the final fragment
+	 * @param rsv
+	 *            reserved bits used for protocol extensions
+	 * @param text
+	 *            text content of the frame.
+	 */
+	public ContinuationWebSocketFrame(boolean finalFragment, int rsv, String text) {
+		this.setFinalFragment(finalFragment);
+		this.setRsv(rsv);
+		this.setText(text);
+	}
 
-    /**
-     * Returns the text data in this frame
-     */
-    public String getText() {
-        if (this.getBinaryData() == null) {
-            return null;
-        }
-        return this.getBinaryData().toString(CharsetUtil.UTF_8);
-    }
+	/**
+	 * Returns the text data in this frame
+	 */
+	public String getText() {
+		if (this.getBinaryData() == null) {
+			return null;
+		}
+		return this.getBinaryData().toString(CharsetUtil.UTF_8);
+	}
 
-    /**
-     * Sets the string for this frame
-     * 
-     * @param text
-     *            text to store
-     */
-    public void setText(String text) {
-        if (text == null || text.isEmpty()) {
-            this.setBinaryData(ChannelBuffers.EMPTY_BUFFER);
-        } else {
-            this.setBinaryData(ChannelBuffers.copiedBuffer(text, CharsetUtil.UTF_8));
-        }
-    }
+	/**
+	 * Sets the string for this frame
+	 * 
+	 * @param text
+	 *            text to store
+	 */
+	public void setText(String text) {
+		if (text == null || text.isEmpty()) {
+			this.setBinaryData(ChannelBuffers.EMPTY_BUFFER);
+		} else {
+			this.setBinaryData(ChannelBuffers.copiedBuffer(text, CharsetUtil.UTF_8));
+		}
+	}
 
-    @Override
-    public String toString() {
-        return getClass().getSimpleName() + "(data: " + getBinaryData() + ')';
-    }
+	@Override
+	public String toString() {
+		return getClass().getSimpleName() + "(data: " + getBinaryData() + ')';
+	}
 
-    /**
-     * Aggregated text returned by decoder on the final continuation frame of a
-     * fragmented text message
-     */
-    public String getAggregatedText() {
-        return aggregatedText;
-    }
+	/**
+	 * Aggregated text returned by decoder on the final continuation frame of a fragmented text message
+	 */
+	public String getAggregatedText() {
+		return aggregatedText;
+	}
 
-    public void setAggregatedText(String aggregatedText) {
-        this.aggregatedText = aggregatedText;
-    }
+	public void setAggregatedText(String aggregatedText) {
+		this.aggregatedText = aggregatedText;
+	}
 
 }
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/PingWebSocketFrame.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/PingWebSocketFrame.java
index c9a6178c68..6399d73300 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/PingWebSocketFrame.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/PingWebSocketFrame.java
@@ -23,43 +23,43 @@ import org.jboss.netty.buffer.ChannelBuffers;
  */
 public class PingWebSocketFrame extends WebSocketFrame {
 
-    /**
-     * Creates a new empty ping frame.
-     */
-    public PingWebSocketFrame() {
-        this.setFinalFragment(true);
-        this.setBinaryData(ChannelBuffers.EMPTY_BUFFER);
-    }
+	/**
+	 * Creates a new empty ping frame.
+	 */
+	public PingWebSocketFrame() {
+		this.setFinalFragment(true);
+		this.setBinaryData(ChannelBuffers.EMPTY_BUFFER);
+	}
 
-    /**
-     * Creates a new ping frame with the specified binary data.
-     * 
-     * @param binaryData
-     *            the content of the frame.
-     */
-    public PingWebSocketFrame(ChannelBuffer binaryData) {
-        this.setBinaryData(binaryData);
-    }
+	/**
+	 * Creates a new ping frame with the specified binary data.
+	 * 
+	 * @param binaryData
+	 *            the content of the frame.
+	 */
+	public PingWebSocketFrame(ChannelBuffer binaryData) {
+		this.setBinaryData(binaryData);
+	}
 
-    /**
-     * Creates a new ping frame with the specified binary data
-     * 
-     * @param finalFragment
-     *            flag indicating if this frame is the final fragment
-     * @param rsv
-     *            reserved bits used for protocol extensions
-     * @param binaryData
-     *            the content of the frame.
-     */
-    public PingWebSocketFrame(boolean finalFragment, int rsv, ChannelBuffer binaryData) {
-        this.setFinalFragment(finalFragment);
-        this.setRsv(rsv);
-        this.setBinaryData(binaryData);
-    }
+	/**
+	 * Creates a new ping frame with the specified binary data
+	 * 
+	 * @param finalFragment
+	 *            flag indicating if this frame is the final fragment
+	 * @param rsv
+	 *            reserved bits used for protocol extensions
+	 * @param binaryData
+	 *            the content of the frame.
+	 */
+	public PingWebSocketFrame(boolean finalFragment, int rsv, ChannelBuffer binaryData) {
+		this.setFinalFragment(finalFragment);
+		this.setRsv(rsv);
+		this.setBinaryData(binaryData);
+	}
 
-    @Override
-    public String toString() {
-        return getClass().getSimpleName() + "(data: " + getBinaryData() + ')';
-    }
+	@Override
+	public String toString() {
+		return getClass().getSimpleName() + "(data: " + getBinaryData() + ')';
+	}
 
 }
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/PongWebSocketFrame.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/PongWebSocketFrame.java
index bfb303a8e9..634711fe1a 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/PongWebSocketFrame.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/PongWebSocketFrame.java
@@ -23,42 +23,42 @@ import org.jboss.netty.buffer.ChannelBuffers;
  */
 public class PongWebSocketFrame extends WebSocketFrame {
 
-    /**
-     * Creates a new empty pong frame.
-     */
-    public PongWebSocketFrame() {
-        this.setBinaryData(ChannelBuffers.EMPTY_BUFFER);
-    }
+	/**
+	 * Creates a new empty pong frame.
+	 */
+	public PongWebSocketFrame() {
+		this.setBinaryData(ChannelBuffers.EMPTY_BUFFER);
+	}
 
-    /**
-     * Creates a new pong frame with the specified binary data.
-     * 
-     * @param binaryData
-     *            the content of the frame.
-     */
-    public PongWebSocketFrame(ChannelBuffer binaryData) {
-        this.setBinaryData(binaryData);
-    }
+	/**
+	 * Creates a new pong frame with the specified binary data.
+	 * 
+	 * @param binaryData
+	 *            the content of the frame.
+	 */
+	public PongWebSocketFrame(ChannelBuffer binaryData) {
+		this.setBinaryData(binaryData);
+	}
 
-    /**
-     * Creates a new pong frame with the specified binary data
-     * 
-     * @param finalFragment
-     *            flag indicating if this frame is the final fragment
-     * @param rsv
-     *            reserved bits used for protocol extensions
-     * @param binaryData
-     *            the content of the frame.
-     */
-    public PongWebSocketFrame(boolean finalFragment, int rsv, ChannelBuffer binaryData) {
-        this.setFinalFragment(finalFragment);
-        this.setRsv(rsv);
-        this.setBinaryData(binaryData);
-    }
+	/**
+	 * Creates a new pong frame with the specified binary data
+	 * 
+	 * @param finalFragment
+	 *            flag indicating if this frame is the final fragment
+	 * @param rsv
+	 *            reserved bits used for protocol extensions
+	 * @param binaryData
+	 *            the content of the frame.
+	 */
+	public PongWebSocketFrame(boolean finalFragment, int rsv, ChannelBuffer binaryData) {
+		this.setFinalFragment(finalFragment);
+		this.setRsv(rsv);
+		this.setBinaryData(binaryData);
+	}
 
-    @Override
-    public String toString() {
-        return getClass().getSimpleName() + "(data: " + getBinaryData() + ')';
-    }
+	@Override
+	public String toString() {
+		return getClass().getSimpleName() + "(data: " + getBinaryData() + ')';
+	}
 
 }
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/TextWebSocketFrame.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/TextWebSocketFrame.java
index 9e0da628c6..ce03bf4132 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/TextWebSocketFrame.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/TextWebSocketFrame.java
@@ -24,102 +24,98 @@ import org.jboss.netty.util.CharsetUtil;
  */
 public class TextWebSocketFrame extends WebSocketFrame {
 
-    /**
-     * Creates a new empty text frame.
-     */
-    public TextWebSocketFrame() {
-        this.setBinaryData(ChannelBuffers.EMPTY_BUFFER);
-    }
+	/**
+	 * Creates a new empty text frame.
+	 */
+	public TextWebSocketFrame() {
+		this.setBinaryData(ChannelBuffers.EMPTY_BUFFER);
+	}
 
-    /**
-     * Creates a new text frame with the specified text string. The final
-     * fragment flag is set to true.
-     * 
-     * @param text
-     *            String to put in the frame
-     */
-    public TextWebSocketFrame(String text) {
-        if (text == null || text.isEmpty()) {
-            this.setBinaryData(ChannelBuffers.EMPTY_BUFFER);
-        } else {
-            this.setBinaryData(ChannelBuffers.copiedBuffer(text, CharsetUtil.UTF_8));
-        }
-    }
+	/**
+	 * Creates a new text frame with the specified text string. The final fragment flag is set to true.
+	 * 
+	 * @param text
+	 *            String to put in the frame
+	 */
+	public TextWebSocketFrame(String text) {
+		if (text == null || text.isEmpty()) {
+			this.setBinaryData(ChannelBuffers.EMPTY_BUFFER);
+		} else {
+			this.setBinaryData(ChannelBuffers.copiedBuffer(text, CharsetUtil.UTF_8));
+		}
+	}
 
-    /**
-     * Creates a new text frame with the specified binary data. The final
-     * fragment flag is set to true.
-     * 
-     * @param binaryData
-     *            the content of the frame. Must be UTF-8 encoded
-     */
-    public TextWebSocketFrame(ChannelBuffer binaryData) {
-        this.setBinaryData(binaryData);
-    }
+	/**
+	 * Creates a new text frame with the specified binary data. The final fragment flag is set to true.
+	 * 
+	 * @param binaryData
+	 *            the content of the frame. Must be UTF-8 encoded
+	 */
+	public TextWebSocketFrame(ChannelBuffer binaryData) {
+		this.setBinaryData(binaryData);
+	}
 
-    /**
-     * Creates a new text frame with the specified text string. The final
-     * fragment flag is set to true.
-     * 
-     * @param finalFragment
-     *            flag indicating if this frame is the final fragment
-     * @param rsv
-     *            reserved bits used for protocol extensions
-     * @param text
-     *            String to put in the frame
-     */
-    public TextWebSocketFrame(boolean finalFragment, int rsv, String text) {
-        this.setFinalFragment(finalFragment);
-        this.setRsv(rsv);
-        if (text == null || text.isEmpty()) {
-            this.setBinaryData(ChannelBuffers.EMPTY_BUFFER);
-        } else {
-            this.setBinaryData(ChannelBuffers.copiedBuffer(text, CharsetUtil.UTF_8));
-        }
-    }
+	/**
+	 * Creates a new text frame with the specified text string. The final fragment flag is set to true.
+	 * 
+	 * @param finalFragment
+	 *            flag indicating if this frame is the final fragment
+	 * @param rsv
+	 *            reserved bits used for protocol extensions
+	 * @param text
+	 *            String to put in the frame
+	 */
+	public TextWebSocketFrame(boolean finalFragment, int rsv, String text) {
+		this.setFinalFragment(finalFragment);
+		this.setRsv(rsv);
+		if (text == null || text.isEmpty()) {
+			this.setBinaryData(ChannelBuffers.EMPTY_BUFFER);
+		} else {
+			this.setBinaryData(ChannelBuffers.copiedBuffer(text, CharsetUtil.UTF_8));
+		}
+	}
 
-    /**
-     * Creates a new text frame with the specified binary data. The final
-     * fragment flag is set to true.
-     * 
-     * @param finalFragment
-     *            flag indicating if this frame is the final fragment
-     * @param rsv
-     *            reserved bits used for protocol extensions
-     * @param binaryData
-     *            the content of the frame. Must be UTF-8 encoded
-     */
-    public TextWebSocketFrame(boolean finalFragment, int rsv, ChannelBuffer binaryData) {
-        this.setFinalFragment(finalFragment);
-        this.setRsv(rsv);
-        this.setBinaryData(binaryData);
-    }
+	/**
+	 * Creates a new text frame with the specified binary data. The final fragment flag is set to true.
+	 * 
+	 * @param finalFragment
+	 *            flag indicating if this frame is the final fragment
+	 * @param rsv
+	 *            reserved bits used for protocol extensions
+	 * @param binaryData
+	 *            the content of the frame. Must be UTF-8 encoded
+	 */
+	public TextWebSocketFrame(boolean finalFragment, int rsv, ChannelBuffer binaryData) {
+		this.setFinalFragment(finalFragment);
+		this.setRsv(rsv);
+		this.setBinaryData(binaryData);
+	}
 
-    /**
-     * Returns the text data in this frame
-     */
-    public String getText() {
-        if (this.getBinaryData() == null) {
-            return null;
-        }
-        return this.getBinaryData().toString(CharsetUtil.UTF_8);
-    }
+	/**
+	 * Returns the text data in this frame
+	 */
+	public String getText() {
+		if (this.getBinaryData() == null) {
+			return null;
+		}
+		return this.getBinaryData().toString(CharsetUtil.UTF_8);
+	}
 
-    /**
-     * Sets the string for this frame
-     * 
-     * @param text
-     *            text to store
-     */
-    public void setText(String text) {
-        if (text == null) {
-            throw new NullPointerException("text");
-        }
-        this.setBinaryData(ChannelBuffers.copiedBuffer(text, CharsetUtil.UTF_8));
-    }
+	/**
+	 * Sets the string for this frame
+	 * 
+	 * @param text
+	 *            text to store
+	 */
+	public void setText(String text) {
+		if (text == null) {
+			throw new NullPointerException("text");
+		}
+		this.setBinaryData(ChannelBuffers.copiedBuffer(text, CharsetUtil.UTF_8));
+	}
 
-    @Override
-    public String toString() {
-        return getClass().getSimpleName() + "(text: " + getText() + ')';
-    }
+	@Override
+	public String toString() {
+		return getClass().getSimpleName() + "(text: " + getText() + ')';
+	}
 }
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/UTF8Exception.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/UTF8Exception.java
index 2cae22e0fd..608e394dae 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/UTF8Exception.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/UTF8Exception.java
@@ -23,9 +23,9 @@ package org.jboss.netty.handler.codec.http.websocketx;
  * Invalid UTF8 bytes encountered
  */
 final class UTF8Exception extends RuntimeException {
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    UTF8Exception(String reason) {
-        super(reason);
-    }
+	UTF8Exception(String reason) {
+		super(reason);
+	}
 }
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/UTF8Output.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/UTF8Output.java
index 4001463f23..d623aa9594 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/UTF8Output.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/UTF8Output.java
@@ -23,51 +23,59 @@ package org.jboss.netty.handler.codec.http.websocketx;
  * Checks UTF8 bytes for validity before converting it into a string
  */
 final class UTF8Output {
-    private static final int UTF8_ACCEPT = 0;
-    private static final int UTF8_REJECT = 12;
+	private static final int UTF8_ACCEPT = 0;
+	private static final int UTF8_REJECT = 12;
 
-    private static final byte[] TYPES = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-            7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 10, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 11, 6, 6, 6, 5, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 };
+	private static final byte[] TYPES = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
+			1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+			7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+			2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 10, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 11,
+			6, 6, 6, 5, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 };
 
-    private static final byte[] STATES = { 0, 12, 24, 36, 60, 96, 84, 12, 12, 12, 48, 72, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 0, 12, 12, 12, 12, 12, 0, 12, 0, 12, 12, 12, 24, 12, 12, 12, 12, 12, 24, 12, 24, 12, 12, 12, 12, 12, 12, 12, 12, 12, 24, 12, 12, 12, 12, 12, 24, 12, 12, 12,
-            12, 12, 12, 12, 24, 12, 12, 12, 12, 12, 12, 12, 12, 12, 36, 12, 36, 12, 12, 12, 36, 12, 12, 12, 12, 12, 36, 12, 36, 12, 12, 12, 36, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12 };
+	private static final byte[] STATES = { 0, 12, 24, 36, 60, 96, 84, 12, 12, 12, 48, 72, 12, 12, 12, 12, 12, 12, 12,
+			12, 12, 12, 12, 12, 12, 0, 12, 12, 12, 12, 12, 0, 12, 0, 12, 12, 12, 24, 12, 12, 12, 12, 12, 24, 12, 24,
+			12, 12, 12, 12, 12, 12, 12, 12, 12, 24, 12, 12, 12, 12, 12, 24, 12, 12, 12, 12, 12, 12, 12, 24, 12, 12, 12,
+			12, 12, 12, 12, 12, 12, 36, 12, 36, 12, 12, 12, 36, 12, 12, 12, 12, 12, 36, 12, 36, 12, 12, 12, 36, 12, 12,
+			12, 12, 12, 12, 12, 12, 12, 12 };
 
-    private int state = UTF8_ACCEPT;
-    private int codep = 0;
+	private int state = UTF8_ACCEPT;
+	private int codep = 0;
 
-    private final StringBuilder stringBuilder;
+	private final StringBuilder stringBuilder;
 
-    UTF8Output(byte[] bytes) {
-        stringBuilder = new StringBuilder(bytes.length);
-        write(bytes);
-    }
+	UTF8Output(byte[] bytes) {
+		stringBuilder = new StringBuilder(bytes.length);
+		write(bytes);
+	}
 
-    public void write(byte[] bytes) {
-        for (byte b : bytes) {
-            write(b);
-        }
-    }
+	public void write(byte[] bytes) {
+		for (byte b : bytes) {
+			write(b);
+		}
+	}
 
-    public void write(int b) {
-        byte type = TYPES[b & 0xFF];
+	public void write(int b) {
+		byte type = TYPES[b & 0xFF];
 
-        codep = (state != UTF8_ACCEPT) ? (b & 0x3f) | (codep << 6) : (0xff >> type) & (b);
+		codep = (state != UTF8_ACCEPT) ? (b & 0x3f) | (codep << 6) : (0xff >> type) & (b);
 
-        state = STATES[state + type];
+		state = STATES[state + type];
 
-        if (state == UTF8_ACCEPT) {
-            stringBuilder.append((char) codep);
-        } else if (state == UTF8_REJECT) {
-            throw new UTF8Exception("bytes are not UTF-8");
-        }
-    }
+		if (state == UTF8_ACCEPT) {
+			stringBuilder.append((char) codep);
+		} else if (state == UTF8_REJECT) {
+			throw new UTF8Exception("bytes are not UTF-8");
+		}
+	}
 
-    @Override
-    public String toString() {
-        if (state != UTF8_ACCEPT) {
-            throw new UTF8Exception("bytes are not UTF-8");
-        }
-        return stringBuilder.toString();
-    }
+	@Override
+	public String toString() {
+		if (state != UTF8_ACCEPT) {
+			throw new UTF8Exception("bytes are not UTF-8");
+		}
+		return stringBuilder.toString();
+	}
 }
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket00FrameDecoder.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket00FrameDecoder.java
index c5936f217f..841fba9499 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket00FrameDecoder.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket00FrameDecoder.java
@@ -25,109 +25,109 @@ import org.jboss.netty.handler.codec.replay.VoidEnum;
 /**
  * Decodes {@link ChannelBuffer}s into {@link WebSocketFrame}s.
  * <p>
- * For the detailed instruction on adding add Web Socket support to your HTTP
- * server, take a look into the <tt>WebSocketServer</tt> example located in the
- * {@code org.jboss.netty.example.http.websocket} package.
+ * For the detailed instruction on adding add Web Socket support to your HTTP server, take a look into the
+ * <tt>WebSocketServer</tt> example located in the {@code org.jboss.netty.example.http.websocket} package.
+ * 
  * @apiviz.landmark
  * @apiviz.uses org.jboss.netty.handler.codec.http.websocket.WebSocketFrame
  */
 public class WebSocket00FrameDecoder extends ReplayingDecoder<VoidEnum> {
 
-    public static final int DEFAULT_MAX_FRAME_SIZE = 16384;
+	public static final int DEFAULT_MAX_FRAME_SIZE = 16384;
 
-    private final int maxFrameSize;
-    private boolean receivedClosingHandshake;
+	private final int maxFrameSize;
+	private boolean receivedClosingHandshake;
 
-    public WebSocket00FrameDecoder() {
-        this(DEFAULT_MAX_FRAME_SIZE);
-    }
+	public WebSocket00FrameDecoder() {
+		this(DEFAULT_MAX_FRAME_SIZE);
+	}
 
-    /**
-     * Creates a new instance of {@code WebSocketFrameDecoder} with the
-     * specified {@code maxFrameSize}. If the client sends a frame size larger
-     * than {@code maxFrameSize}, the channel will be closed.
-     * 
-     * @param maxFrameSize
-     *            the maximum frame size to decode
-     */
-    public WebSocket00FrameDecoder(int maxFrameSize) {
-        this.maxFrameSize = maxFrameSize;
-    }
+	/**
+	 * Creates a new instance of {@code WebSocketFrameDecoder} with the specified {@code maxFrameSize}. If the client
+	 * sends a frame size larger than {@code maxFrameSize}, the channel will be closed.
+	 * 
+	 * @param maxFrameSize
+	 *            the maximum frame size to decode
+	 */
+	public WebSocket00FrameDecoder(int maxFrameSize) {
+		this.maxFrameSize = maxFrameSize;
+	}
 
-    @Override
-    protected Object decode(ChannelHandlerContext ctx, Channel channel, ChannelBuffer buffer, VoidEnum state) throws Exception {
+	@Override
+	protected Object decode(ChannelHandlerContext ctx, Channel channel, ChannelBuffer buffer, VoidEnum state)
+			throws Exception {
 
-        // Discard all data received if closing handshake was received before.
-        if (receivedClosingHandshake) {
-            buffer.skipBytes(actualReadableBytes());
-            return null;
-        }
+		// Discard all data received if closing handshake was received before.
+		if (receivedClosingHandshake) {
+			buffer.skipBytes(actualReadableBytes());
+			return null;
+		}
 
-        // Decode a frame otherwise.
-        byte type = buffer.readByte();
-        if ((type & 0x80) == 0x80) {
-            // If the MSB on type is set, decode the frame length
-            return decodeBinaryFrame(type, buffer);
-        } else {
-            // Decode a 0xff terminated UTF-8 string
-            return decodeTextFrame(type, buffer);
-        }
-    }
+		// Decode a frame otherwise.
+		byte type = buffer.readByte();
+		if ((type & 0x80) == 0x80) {
+			// If the MSB on type is set, decode the frame length
+			return decodeBinaryFrame(type, buffer);
+		} else {
+			// Decode a 0xff terminated UTF-8 string
+			return decodeTextFrame(type, buffer);
+		}
+	}
 
-    private WebSocketFrame decodeBinaryFrame(byte type, ChannelBuffer buffer) throws TooLongFrameException {
-        long frameSize = 0;
-        int lengthFieldSize = 0;
-        byte b;
-        do {
-            b = buffer.readByte();
-            frameSize <<= 7;
-            frameSize |= b & 0x7f;
-            if (frameSize > maxFrameSize) {
-                throw new TooLongFrameException();
-            }
-            lengthFieldSize++;
-            if (lengthFieldSize > 8) {
-                // Perhaps a malicious peer?
-                throw new TooLongFrameException();
-            }
-        } while ((b & 0x80) == 0x80);
+	private WebSocketFrame decodeBinaryFrame(byte type, ChannelBuffer buffer) throws TooLongFrameException {
+		long frameSize = 0;
+		int lengthFieldSize = 0;
+		byte b;
+		do {
+			b = buffer.readByte();
+			frameSize <<= 7;
+			frameSize |= b & 0x7f;
+			if (frameSize > maxFrameSize) {
+				throw new TooLongFrameException();
+			}
+			lengthFieldSize++;
+			if (lengthFieldSize > 8) {
+				// Perhaps a malicious peer?
+				throw new TooLongFrameException();
+			}
+		} while ((b & 0x80) == 0x80);
 
-        if (type == ((byte) 0xFF) && frameSize == 0) {
-            receivedClosingHandshake = true;
-            return new CloseWebSocketFrame();
-        }
+		if (type == ((byte) 0xFF) && frameSize == 0) {
+			receivedClosingHandshake = true;
+			return new CloseWebSocketFrame();
+		}
 
-        return new BinaryWebSocketFrame(buffer.readBytes((int) frameSize));
-    }
+		return new BinaryWebSocketFrame(buffer.readBytes((int) frameSize));
+	}
 
-    private WebSocketFrame decodeTextFrame(byte type, ChannelBuffer buffer) throws TooLongFrameException {
-        int ridx = buffer.readerIndex();
-        int rbytes = actualReadableBytes();
-        int delimPos = buffer.indexOf(ridx, ridx + rbytes, (byte) 0xFF);
-        if (delimPos == -1) {
-            // Frame delimiter (0xFF) not found
-            if (rbytes > maxFrameSize) {
-                // Frame length exceeded the maximum
-                throw new TooLongFrameException();
-            } else {
-                // Wait until more data is received
-                return null;
-            }
-        }
+	private WebSocketFrame decodeTextFrame(byte type, ChannelBuffer buffer) throws TooLongFrameException {
+		int ridx = buffer.readerIndex();
+		int rbytes = actualReadableBytes();
+		int delimPos = buffer.indexOf(ridx, ridx + rbytes, (byte) 0xFF);
+		if (delimPos == -1) {
+			// Frame delimiter (0xFF) not found
+			if (rbytes > maxFrameSize) {
+				// Frame length exceeded the maximum
+				throw new TooLongFrameException();
+			} else {
+				// Wait until more data is received
+				return null;
+			}
+		}
 
-        int frameSize = delimPos - ridx;
-        if (frameSize > maxFrameSize) {
-            throw new TooLongFrameException();
-        }
+		int frameSize = delimPos - ridx;
+		if (frameSize > maxFrameSize) {
+			throw new TooLongFrameException();
+		}
 
-        ChannelBuffer binaryData = buffer.readBytes(frameSize);
-        buffer.skipBytes(1);
+		ChannelBuffer binaryData = buffer.readBytes(frameSize);
+		buffer.skipBytes(1);
 
-        int ffDelimPos = binaryData.indexOf(binaryData.readerIndex(), binaryData.writerIndex(), (byte) 0xFF);
-        if (ffDelimPos >= 0) {
-            throw new IllegalArgumentException("a text frame should not contain 0xFF.");
-        }
+		int ffDelimPos = binaryData.indexOf(binaryData.readerIndex(), binaryData.writerIndex(), (byte) 0xFF);
+		if (ffDelimPos >= 0) {
+			throw new IllegalArgumentException("a text frame should not contain 0xFF.");
+		}
 
-        return new TextWebSocketFrame(binaryData);
-    }
+		return new TextWebSocketFrame(binaryData);
+	}
 }
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket00FrameEncoder.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket00FrameEncoder.java
index 48dca72488..a2f7563312 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket00FrameEncoder.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket00FrameEncoder.java
@@ -24,73 +24,74 @@ import org.jboss.netty.handler.codec.oneone.OneToOneEncoder;
 /**
  * Encodes a {@link WebSocketFrame} into a {@link ChannelBuffer}.
  * <p>
- * For the detailed instruction on adding add Web Socket support to your HTTP
- * server, take a look into the <tt>WebSocketServer</tt> example located in the
- * {@code org.jboss.netty.example.http.websocket} package.
+ * For the detailed instruction on adding add Web Socket support to your HTTP server, take a look into the
+ * <tt>WebSocketServer</tt> example located in the {@code org.jboss.netty.example.http.websocket} package.
+ * 
  * @apiviz.landmark
  * @apiviz.uses org.jboss.netty.handler.codec.http.websocket.WebSocketFrame
  */
 @Sharable
 public class WebSocket00FrameEncoder extends OneToOneEncoder {
 
-    @Override
-    protected Object encode(ChannelHandlerContext ctx, Channel channel, Object msg) throws Exception {
-        if (msg instanceof WebSocketFrame) {
-            WebSocketFrame frame = (WebSocketFrame) msg;
-            if (frame instanceof TextWebSocketFrame) {
-                // Text frame
-                ChannelBuffer data = frame.getBinaryData();
-                ChannelBuffer encoded = channel.getConfig().getBufferFactory().getBuffer(data.order(), data.readableBytes() + 2);
-                encoded.writeByte((byte) 0x00);
-                encoded.writeBytes(data, data.readerIndex(), data.readableBytes());
-                encoded.writeByte((byte) 0xFF);
-                return encoded;
-            } else if (frame instanceof CloseWebSocketFrame) {
-                // Close frame
-                ChannelBuffer data = frame.getBinaryData();
-                ChannelBuffer encoded = channel.getConfig().getBufferFactory().getBuffer(data.order(), 2);
-                encoded.writeByte((byte) 0xFF);
-                encoded.writeByte((byte) 0x00);
-                return encoded;
-            } else {
-                // Binary frame
-                ChannelBuffer data = frame.getBinaryData();
-                int dataLen = data.readableBytes();
-                ChannelBuffer encoded = channel.getConfig().getBufferFactory().getBuffer(data.order(), dataLen + 5);
+	@Override
+	protected Object encode(ChannelHandlerContext ctx, Channel channel, Object msg) throws Exception {
+		if (msg instanceof WebSocketFrame) {
+			WebSocketFrame frame = (WebSocketFrame) msg;
+			if (frame instanceof TextWebSocketFrame) {
+				// Text frame
+				ChannelBuffer data = frame.getBinaryData();
+				ChannelBuffer encoded = channel.getConfig().getBufferFactory()
+						.getBuffer(data.order(), data.readableBytes() + 2);
+				encoded.writeByte((byte) 0x00);
+				encoded.writeBytes(data, data.readerIndex(), data.readableBytes());
+				encoded.writeByte((byte) 0xFF);
+				return encoded;
+			} else if (frame instanceof CloseWebSocketFrame) {
+				// Close frame
+				ChannelBuffer data = frame.getBinaryData();
+				ChannelBuffer encoded = channel.getConfig().getBufferFactory().getBuffer(data.order(), 2);
+				encoded.writeByte((byte) 0xFF);
+				encoded.writeByte((byte) 0x00);
+				return encoded;
+			} else {
+				// Binary frame
+				ChannelBuffer data = frame.getBinaryData();
+				int dataLen = data.readableBytes();
+				ChannelBuffer encoded = channel.getConfig().getBufferFactory().getBuffer(data.order(), dataLen + 5);
 
-                // Encode type.
-                encoded.writeByte((byte) 0x80);
+				// Encode type.
+				encoded.writeByte((byte) 0x80);
 
-                // Encode length.
-                int b1 = dataLen >>> 28 & 0x7F;
-                int b2 = dataLen >>> 14 & 0x7F;
-                int b3 = dataLen >>> 7 & 0x7F;
-                int b4 = dataLen & 0x7F;
-                if (b1 == 0) {
-                    if (b2 == 0) {
-                        if (b3 == 0) {
-                            encoded.writeByte(b4);
-                        } else {
-                            encoded.writeByte(b3 | 0x80);
-                            encoded.writeByte(b4);
-                        }
-                    } else {
-                        encoded.writeByte(b2 | 0x80);
-                        encoded.writeByte(b3 | 0x80);
-                        encoded.writeByte(b4);
-                    }
-                } else {
-                    encoded.writeByte(b1 | 0x80);
-                    encoded.writeByte(b2 | 0x80);
-                    encoded.writeByte(b3 | 0x80);
-                    encoded.writeByte(b4);
-                }
+				// Encode length.
+				int b1 = dataLen >>> 28 & 0x7F;
+				int b2 = dataLen >>> 14 & 0x7F;
+				int b3 = dataLen >>> 7 & 0x7F;
+				int b4 = dataLen & 0x7F;
+				if (b1 == 0) {
+					if (b2 == 0) {
+						if (b3 == 0) {
+							encoded.writeByte(b4);
+						} else {
+							encoded.writeByte(b3 | 0x80);
+							encoded.writeByte(b4);
+						}
+					} else {
+						encoded.writeByte(b2 | 0x80);
+						encoded.writeByte(b3 | 0x80);
+						encoded.writeByte(b4);
+					}
+				} else {
+					encoded.writeByte(b1 | 0x80);
+					encoded.writeByte(b2 | 0x80);
+					encoded.writeByte(b3 | 0x80);
+					encoded.writeByte(b4);
+				}
 
-                // Encode binary data.
-                encoded.writeBytes(data, data.readerIndex(), dataLen);
-                return encoded;
-            }
-        }
-        return msg;
-    }
+				// Encode binary data.
+				encoded.writeBytes(data, data.readerIndex(), dataLen);
+				return encoded;
+			}
+		}
+		return msg;
+	}
 }
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket08FrameDecoder.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket08FrameDecoder.java
index 44c4bcf4b3..5c15118a83 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket08FrameDecoder.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket08FrameDecoder.java
@@ -50,331 +50,330 @@ import org.jboss.netty.logging.InternalLogger;
 import org.jboss.netty.logging.InternalLoggerFactory;
 
 /**
- * Decodes a web socket frame from wire protocol version 8 format. This code was
- * forked from <a href="https://github.com/joewalnes/webbit">webbit</a> and
- * modified.
+ * Decodes a web socket frame from wire protocol version 8 format. This code was forked from <a
+ * href="https://github.com/joewalnes/webbit">webbit</a> and modified.
  */
 public class WebSocket08FrameDecoder extends ReplayingDecoder<WebSocket08FrameDecoder.State> {
 
-    private static final InternalLogger logger = InternalLoggerFactory.getInstance(WebSocket08FrameDecoder.class);
+	private static final InternalLogger logger = InternalLoggerFactory.getInstance(WebSocket08FrameDecoder.class);
 
-    private static final byte OPCODE_CONT = 0x0;
-    private static final byte OPCODE_TEXT = 0x1;
-    private static final byte OPCODE_BINARY = 0x2;
-    private static final byte OPCODE_CLOSE = 0x8;
-    private static final byte OPCODE_PING = 0x9;
-    private static final byte OPCODE_PONG = 0xA;
+	private static final byte OPCODE_CONT = 0x0;
+	private static final byte OPCODE_TEXT = 0x1;
+	private static final byte OPCODE_BINARY = 0x2;
+	private static final byte OPCODE_CLOSE = 0x8;
+	private static final byte OPCODE_PING = 0x9;
+	private static final byte OPCODE_PONG = 0xA;
 
-    private UTF8Output fragmentedFramesText = null;
-    private int fragmentedFramesCount = 0;
+	private UTF8Output fragmentedFramesText = null;
+	private int fragmentedFramesCount = 0;
 
-    private boolean frameFinalFlag;
-    private int frameRsv;
-    private int frameOpcode;
-    private long framePayloadLength;
-    private ChannelBuffer framePayload = null;
-    private int framePayloadBytesRead = 0;
-    private ChannelBuffer maskingKey;
+	private boolean frameFinalFlag;
+	private int frameRsv;
+	private int frameOpcode;
+	private long framePayloadLength;
+	private ChannelBuffer framePayload = null;
+	private int framePayloadBytesRead = 0;
+	private ChannelBuffer maskingKey;
 
-    private boolean allowExtensions = false;
-    private boolean maskedPayload = false;
-    private boolean receivedClosingHandshake = false;
+	private boolean allowExtensions = false;
+	private boolean maskedPayload = false;
+	private boolean receivedClosingHandshake = false;
 
-    public enum State {
-        FRAME_START, MASKING_KEY, PAYLOAD, CORRUPT
-    }
+	public enum State {
+		FRAME_START, MASKING_KEY, PAYLOAD, CORRUPT
+	}
 
-    /**
-     * Constructor
-     * 
-     * @param maskedPayload
-     *            Web socket servers must set this to true processed incoming
-     *            masked payload. Client implementations must set this to false.
-     * @param allowExtensions
-     *            Flag to allow reserved extension bits to be used or not
-     */
-    public WebSocket08FrameDecoder(boolean maskedPayload, boolean allowExtensions) {
-        super(State.FRAME_START);
-        this.maskedPayload = maskedPayload;
-        this.allowExtensions = allowExtensions;
-    }
+	/**
+	 * Constructor
+	 * 
+	 * @param maskedPayload
+	 *            Web socket servers must set this to true processed incoming masked payload. Client implementations
+	 *            must set this to false.
+	 * @param allowExtensions
+	 *            Flag to allow reserved extension bits to be used or not
+	 */
+	public WebSocket08FrameDecoder(boolean maskedPayload, boolean allowExtensions) {
+		super(State.FRAME_START);
+		this.maskedPayload = maskedPayload;
+		this.allowExtensions = allowExtensions;
+	}
 
-    @Override
-    protected Object decode(ChannelHandlerContext ctx, Channel channel, ChannelBuffer buffer, State state)
-            throws Exception {
+	@Override
+	protected Object decode(ChannelHandlerContext ctx, Channel channel, ChannelBuffer buffer, State state)
+			throws Exception {
 
-        // Discard all data received if closing handshake was received before.
-        if (receivedClosingHandshake) {
-            buffer.skipBytes(actualReadableBytes());
-            return null;
-        }
+		// Discard all data received if closing handshake was received before.
+		if (receivedClosingHandshake) {
+			buffer.skipBytes(actualReadableBytes());
+			return null;
+		}
 
-        switch (state) {
-        case FRAME_START:
-            framePayloadBytesRead = 0;
-            framePayloadLength = -1;
-            framePayload = null;
+		switch (state) {
+		case FRAME_START:
+			framePayloadBytesRead = 0;
+			framePayloadLength = -1;
+			framePayload = null;
 
-            // FIN, RSV, OPCODE
-            byte b = buffer.readByte();
-            frameFinalFlag = (b & 0x80) != 0;
-            frameRsv = (b & 0x70) >> 4;
-            frameOpcode = (b & 0x0F);
+			// FIN, RSV, OPCODE
+			byte b = buffer.readByte();
+			frameFinalFlag = (b & 0x80) != 0;
+			frameRsv = (b & 0x70) >> 4;
+			frameOpcode = (b & 0x0F);
 
-            if (logger.isDebugEnabled()) {
-                logger.debug("Decoding WebSocket Frame opCode=" + frameOpcode);
-            }
+			if (logger.isDebugEnabled()) {
+				logger.debug("Decoding WebSocket Frame opCode=" + frameOpcode);
+			}
 
-            // MASK, PAYLOAD LEN 1
-            b = buffer.readByte();
-            boolean frameMasked = (b & 0x80) != 0;
-            int framePayloadLen1 = (b & 0x7F);
+			// MASK, PAYLOAD LEN 1
+			b = buffer.readByte();
+			boolean frameMasked = (b & 0x80) != 0;
+			int framePayloadLen1 = (b & 0x7F);
 
-            if (frameRsv != 0 && !this.allowExtensions) {
-                protocolViolation(channel, "RSV != 0 and no extension negotiated, RSV:" + frameRsv);
-                return null;
-            }
+			if (frameRsv != 0 && !this.allowExtensions) {
+				protocolViolation(channel, "RSV != 0 and no extension negotiated, RSV:" + frameRsv);
+				return null;
+			}
 
-            if (this.maskedPayload && !frameMasked) {
-                protocolViolation(channel, "unmasked client to server frame");
-                return null;
-            }
-            if (frameOpcode > 7) { // control frame (have MSB in opcode set)
+			if (this.maskedPayload && !frameMasked) {
+				protocolViolation(channel, "unmasked client to server frame");
+				return null;
+			}
+			if (frameOpcode > 7) { // control frame (have MSB in opcode set)
 
-                // control frames MUST NOT be fragmented
-                if (!frameFinalFlag) {
-                    protocolViolation(channel, "fragmented control frame");
-                    return null;
-                }
+				// control frames MUST NOT be fragmented
+				if (!frameFinalFlag) {
+					protocolViolation(channel, "fragmented control frame");
+					return null;
+				}
 
-                // control frames MUST have payload 125 octets or less
-                if (framePayloadLen1 > 125) {
-                    protocolViolation(channel, "control frame with payload length > 125 octets");
-                    return null;
-                }
+				// control frames MUST have payload 125 octets or less
+				if (framePayloadLen1 > 125) {
+					protocolViolation(channel, "control frame with payload length > 125 octets");
+					return null;
+				}
 
-                // check for reserved control frame opcodes
-                if (!(frameOpcode == OPCODE_CLOSE || frameOpcode == OPCODE_PING || frameOpcode == OPCODE_PONG)) {
-                    protocolViolation(channel, "control frame using reserved opcode " + frameOpcode);
-                    return null;
-                }
+				// check for reserved control frame opcodes
+				if (!(frameOpcode == OPCODE_CLOSE || frameOpcode == OPCODE_PING || frameOpcode == OPCODE_PONG)) {
+					protocolViolation(channel, "control frame using reserved opcode " + frameOpcode);
+					return null;
+				}
 
-                // close frame : if there is a body, the first two bytes of the
-                // body MUST be a 2-byte unsigned integer (in network byte
-                // order) representing a status code
-                if (frameOpcode == 8 && framePayloadLen1 == 1) {
-                    protocolViolation(channel, "received close control frame with payload len 1");
-                    return null;
-                }
-            } else { // data frame
-                // check for reserved data frame opcodes
-                if (!(frameOpcode == OPCODE_CONT || frameOpcode == OPCODE_TEXT || frameOpcode == OPCODE_BINARY)) {
-                    protocolViolation(channel, "data frame using reserved opcode " + frameOpcode);
-                    return null;
-                }
+				// close frame : if there is a body, the first two bytes of the
+				// body MUST be a 2-byte unsigned integer (in network byte
+				// order) representing a status code
+				if (frameOpcode == 8 && framePayloadLen1 == 1) {
+					protocolViolation(channel, "received close control frame with payload len 1");
+					return null;
+				}
+			} else { // data frame
+				// check for reserved data frame opcodes
+				if (!(frameOpcode == OPCODE_CONT || frameOpcode == OPCODE_TEXT || frameOpcode == OPCODE_BINARY)) {
+					protocolViolation(channel, "data frame using reserved opcode " + frameOpcode);
+					return null;
+				}
 
-                // check opcode vs message fragmentation state 1/2
-                if (fragmentedFramesCount == 0 && frameOpcode == OPCODE_CONT) {
-                    protocolViolation(channel, "received continuation data frame outside fragmented message");
-                    return null;
-                }
+				// check opcode vs message fragmentation state 1/2
+				if (fragmentedFramesCount == 0 && frameOpcode == OPCODE_CONT) {
+					protocolViolation(channel, "received continuation data frame outside fragmented message");
+					return null;
+				}
 
-                // check opcode vs message fragmentation state 2/2
-                if (fragmentedFramesCount != 0 && frameOpcode != OPCODE_CONT && frameOpcode != OPCODE_PING) {
-                    protocolViolation(channel, "received non-continuation data frame while inside fragmented message");
-                    return null;
-                }
-            }
+				// check opcode vs message fragmentation state 2/2
+				if (fragmentedFramesCount != 0 && frameOpcode != OPCODE_CONT && frameOpcode != OPCODE_PING) {
+					protocolViolation(channel, "received non-continuation data frame while inside fragmented message");
+					return null;
+				}
+			}
 
-            // Read frame payload length
-            if (framePayloadLen1 == 126) {
-                framePayloadLength = buffer.readUnsignedShort();
-                if (framePayloadLength < 126) {
-                    protocolViolation(channel, "invalid data frame length (not using minimal length encoding)");
-                    return null;
-                }
-            } else if (framePayloadLen1 == 127) {
-                framePayloadLength = buffer.readLong();
-                // TODO: check if it's bigger than 0x7FFFFFFFFFFFFFFF, Maybe
-                // just check if it's negative?
+			// Read frame payload length
+			if (framePayloadLen1 == 126) {
+				framePayloadLength = buffer.readUnsignedShort();
+				if (framePayloadLength < 126) {
+					protocolViolation(channel, "invalid data frame length (not using minimal length encoding)");
+					return null;
+				}
+			} else if (framePayloadLen1 == 127) {
+				framePayloadLength = buffer.readLong();
+				// TODO: check if it's bigger than 0x7FFFFFFFFFFFFFFF, Maybe
+				// just check if it's negative?
 
-                if (framePayloadLength < 65536) {
-                    protocolViolation(channel, "invalid data frame length (not using minimal length encoding)");
-                    return null;
-                }
-            } else {
-                framePayloadLength = framePayloadLen1;
-            }
+				if (framePayloadLength < 65536) {
+					protocolViolation(channel, "invalid data frame length (not using minimal length encoding)");
+					return null;
+				}
+			} else {
+				framePayloadLength = framePayloadLen1;
+			}
 
-            if (logger.isDebugEnabled()) {
-                logger.debug("Decoding WebSocket Frame length=" + framePayloadLength);
-            }
+			if (logger.isDebugEnabled()) {
+				logger.debug("Decoding WebSocket Frame length=" + framePayloadLength);
+			}
 
-            checkpoint(State.MASKING_KEY);
-        case MASKING_KEY:
-            if (this.maskedPayload) {
-                maskingKey = buffer.readBytes(4);
-            }
-            checkpoint(State.PAYLOAD);
-        case PAYLOAD:
-            // Sometimes, the payload may not be delivered in 1 nice packet
-            // We need to accumulate the data until we have it all
-            int rbytes = actualReadableBytes();
-            ChannelBuffer payloadBuffer = null;
+			checkpoint(State.MASKING_KEY);
+		case MASKING_KEY:
+			if (this.maskedPayload) {
+				maskingKey = buffer.readBytes(4);
+			}
+			checkpoint(State.PAYLOAD);
+		case PAYLOAD:
+			// Sometimes, the payload may not be delivered in 1 nice packet
+			// We need to accumulate the data until we have it all
+			int rbytes = actualReadableBytes();
+			ChannelBuffer payloadBuffer = null;
 
-            int willHaveReadByteCount = framePayloadBytesRead + rbytes;
-            // logger.debug("Frame rbytes=" + rbytes + " willHaveReadByteCount="
-            // + willHaveReadByteCount + " framePayloadLength=" +
-            // framePayloadLength);
-            if (willHaveReadByteCount == framePayloadLength) {
-                // We have all our content so proceed to process
-                payloadBuffer = buffer.readBytes(rbytes);
-            } else if (willHaveReadByteCount < framePayloadLength) {
-                // We don't have all our content so accumulate payload.
-                // Returning null means we will get called back
-                payloadBuffer = buffer.readBytes(rbytes);
-                if (framePayload == null) {
-                    framePayload = channel.getConfig().getBufferFactory().getBuffer(toFrameLength(framePayloadLength));
-                }
-                framePayload.writeBytes(payloadBuffer);
-                framePayloadBytesRead = framePayloadBytesRead + rbytes;
+			int willHaveReadByteCount = framePayloadBytesRead + rbytes;
+			// logger.debug("Frame rbytes=" + rbytes + " willHaveReadByteCount="
+			// + willHaveReadByteCount + " framePayloadLength=" +
+			// framePayloadLength);
+			if (willHaveReadByteCount == framePayloadLength) {
+				// We have all our content so proceed to process
+				payloadBuffer = buffer.readBytes(rbytes);
+			} else if (willHaveReadByteCount < framePayloadLength) {
+				// We don't have all our content so accumulate payload.
+				// Returning null means we will get called back
+				payloadBuffer = buffer.readBytes(rbytes);
+				if (framePayload == null) {
+					framePayload = channel.getConfig().getBufferFactory().getBuffer(toFrameLength(framePayloadLength));
+				}
+				framePayload.writeBytes(payloadBuffer);
+				framePayloadBytesRead = framePayloadBytesRead + rbytes;
 
-                // Return null to wait for more bytes to arrive
-                return null;
-            } else if (willHaveReadByteCount > framePayloadLength) {
-                // We have more than what we need so read up to the end of frame
-                // Leave the remainder in the buffer for next frame
-                payloadBuffer = buffer.readBytes(toFrameLength(framePayloadLength - framePayloadBytesRead));
-            }
+				// Return null to wait for more bytes to arrive
+				return null;
+			} else if (willHaveReadByteCount > framePayloadLength) {
+				// We have more than what we need so read up to the end of frame
+				// Leave the remainder in the buffer for next frame
+				payloadBuffer = buffer.readBytes(toFrameLength(framePayloadLength - framePayloadBytesRead));
+			}
 
-            // Now we have all the data, the next checkpoint must be the next
-            // frame
-            checkpoint(State.FRAME_START);
+			// Now we have all the data, the next checkpoint must be the next
+			// frame
+			checkpoint(State.FRAME_START);
 
-            // Take the data that we have in this packet
-            if (framePayload == null) {
-                framePayload = payloadBuffer;
-            } else {
-                framePayload.writeBytes(payloadBuffer);
-            }
+			// Take the data that we have in this packet
+			if (framePayload == null) {
+				framePayload = payloadBuffer;
+			} else {
+				framePayload.writeBytes(payloadBuffer);
+			}
 
-            // Unmask data if needed
-            if (this.maskedPayload) {
-                unmask(framePayload);
-            }
+			// Unmask data if needed
+			if (this.maskedPayload) {
+				unmask(framePayload);
+			}
 
-            // Processing ping/pong/close frames because they cannot be
-            // fragmented
-            if (frameOpcode == OPCODE_PING) {
-                return new PingWebSocketFrame(frameFinalFlag, frameRsv, framePayload);
-            } else if (frameOpcode == OPCODE_PONG) {
-                return new PongWebSocketFrame(frameFinalFlag, frameRsv, framePayload);
-            } else if (frameOpcode == OPCODE_CLOSE) {
-                this.receivedClosingHandshake = true;
-                return new CloseWebSocketFrame(frameFinalFlag, frameRsv);
-            }
+			// Processing ping/pong/close frames because they cannot be
+			// fragmented
+			if (frameOpcode == OPCODE_PING) {
+				return new PingWebSocketFrame(frameFinalFlag, frameRsv, framePayload);
+			} else if (frameOpcode == OPCODE_PONG) {
+				return new PongWebSocketFrame(frameFinalFlag, frameRsv, framePayload);
+			} else if (frameOpcode == OPCODE_CLOSE) {
+				this.receivedClosingHandshake = true;
+				return new CloseWebSocketFrame(frameFinalFlag, frameRsv);
+			}
 
-            // Processing for possible fragmented messages for text and binary
-            // frames
-            String aggregatedText = null;
-            if (frameFinalFlag) {
-                // Final frame of the sequence. Apparently ping frames are
-                // allowed in the middle of a fragmented message
-                if (frameOpcode != OPCODE_PING) {
-                    fragmentedFramesCount = 0;
+			// Processing for possible fragmented messages for text and binary
+			// frames
+			String aggregatedText = null;
+			if (frameFinalFlag) {
+				// Final frame of the sequence. Apparently ping frames are
+				// allowed in the middle of a fragmented message
+				if (frameOpcode != OPCODE_PING) {
+					fragmentedFramesCount = 0;
 
-                    // Check text for UTF8 correctness
-                    if (frameOpcode == OPCODE_TEXT || fragmentedFramesText != null) {
-                        // Check UTF-8 correctness for this payload
-                        checkUTF8String(channel, framePayload.array());
+					// Check text for UTF8 correctness
+					if (frameOpcode == OPCODE_TEXT || fragmentedFramesText != null) {
+						// Check UTF-8 correctness for this payload
+						checkUTF8String(channel, framePayload.array());
 
-                        // This does a second check to make sure UTF-8
-                        // correctness for entire text message
-                        aggregatedText = fragmentedFramesText.toString();
+						// This does a second check to make sure UTF-8
+						// correctness for entire text message
+						aggregatedText = fragmentedFramesText.toString();
 
-                        fragmentedFramesText = null;
-                    }
-                }
-            } else {
-                // Not final frame so we can expect more frames in the
-                // fragmented sequence
-                if (fragmentedFramesCount == 0) {
-                    // First text or binary frame for a fragmented set
-                    fragmentedFramesText = null;
-                    if (frameOpcode == OPCODE_TEXT) {
-                        checkUTF8String(channel, framePayload.array());
-                    }
-                } else {
-                    // Subsequent frames - only check if init frame is text
-                    if (fragmentedFramesText != null) {
-                        checkUTF8String(channel, framePayload.array());
-                    }
-                }
+						fragmentedFramesText = null;
+					}
+				}
+			} else {
+				// Not final frame so we can expect more frames in the
+				// fragmented sequence
+				if (fragmentedFramesCount == 0) {
+					// First text or binary frame for a fragmented set
+					fragmentedFramesText = null;
+					if (frameOpcode == OPCODE_TEXT) {
+						checkUTF8String(channel, framePayload.array());
+					}
+				} else {
+					// Subsequent frames - only check if init frame is text
+					if (fragmentedFramesText != null) {
+						checkUTF8String(channel, framePayload.array());
+					}
+				}
 
-                // Increment counter
-                fragmentedFramesCount++;
-            }
+				// Increment counter
+				fragmentedFramesCount++;
+			}
 
-            // Return the frame
-            if (frameOpcode == OPCODE_TEXT) {
-                return new TextWebSocketFrame(frameFinalFlag, frameRsv, framePayload);
-            } else if (frameOpcode == OPCODE_BINARY) {
-                return new BinaryWebSocketFrame(frameFinalFlag, frameRsv, framePayload);
-            } else if (frameOpcode == OPCODE_CONT) {
-                return new ContinuationWebSocketFrame(frameFinalFlag, frameRsv, framePayload, aggregatedText);
-            } else {
-                throw new UnsupportedOperationException("Cannot decode web socket frame with opcode: " + frameOpcode);
-            }
-        case CORRUPT:
-            // If we don't keep reading Netty will throw an exception saying
-            // we can't return null if no bytes read and state not changed.
-            buffer.readByte();
-            return null;
-        default:
-            throw new Error("Shouldn't reach here.");
-        }
-    }
+			// Return the frame
+			if (frameOpcode == OPCODE_TEXT) {
+				return new TextWebSocketFrame(frameFinalFlag, frameRsv, framePayload);
+			} else if (frameOpcode == OPCODE_BINARY) {
+				return new BinaryWebSocketFrame(frameFinalFlag, frameRsv, framePayload);
+			} else if (frameOpcode == OPCODE_CONT) {
+				return new ContinuationWebSocketFrame(frameFinalFlag, frameRsv, framePayload, aggregatedText);
+			} else {
+				throw new UnsupportedOperationException("Cannot decode web socket frame with opcode: " + frameOpcode);
+			}
+		case CORRUPT:
+			// If we don't keep reading Netty will throw an exception saying
+			// we can't return null if no bytes read and state not changed.
+			buffer.readByte();
+			return null;
+		default:
+			throw new Error("Shouldn't reach here.");
+		}
+	}
 
-    private void unmask(ChannelBuffer frame) {
-        byte[] bytes = frame.array();
-        for (int i = 0; i < bytes.length; i++) {
-            frame.setByte(i, frame.getByte(i) ^ maskingKey.getByte(i % 4));
-        }
-    }
+	private void unmask(ChannelBuffer frame) {
+		byte[] bytes = frame.array();
+		for (int i = 0; i < bytes.length; i++) {
+			frame.setByte(i, frame.getByte(i) ^ maskingKey.getByte(i % 4));
+		}
+	}
 
-    private void protocolViolation(Channel channel, String reason) throws CorruptedFrameException {
-        checkpoint(State.CORRUPT);
-        if (channel.isConnected()) {
-            channel.write(ChannelBuffers.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
-            channel.close().awaitUninterruptibly();
-        }
-        throw new CorruptedFrameException(reason);
-    }
+	private void protocolViolation(Channel channel, String reason) throws CorruptedFrameException {
+		checkpoint(State.CORRUPT);
+		if (channel.isConnected()) {
+			channel.write(ChannelBuffers.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
+			channel.close().awaitUninterruptibly();
+		}
+		throw new CorruptedFrameException(reason);
+	}
 
-    private int toFrameLength(long l) throws TooLongFrameException {
-        if (l > Integer.MAX_VALUE) {
-            throw new TooLongFrameException("Length:" + l);
-        } else {
-            return (int) l;
-        }
-    }
+	private int toFrameLength(long l) throws TooLongFrameException {
+		if (l > Integer.MAX_VALUE) {
+			throw new TooLongFrameException("Length:" + l);
+		} else {
+			return (int) l;
+		}
+	}
 
-    private void checkUTF8String(Channel channel, byte[] bytes) throws CorruptedFrameException {
-        try {
-            // StringBuilder sb = new StringBuilder("UTF8 " + bytes.length +
-            // " bytes: ");
-            // for (byte b : bytes) {
-            // sb.append(Integer.toHexString(b)).append(" ");
-            // }
-            // logger.debug(sb.toString());
+	private void checkUTF8String(Channel channel, byte[] bytes) throws CorruptedFrameException {
+		try {
+			// StringBuilder sb = new StringBuilder("UTF8 " + bytes.length +
+			// " bytes: ");
+			// for (byte b : bytes) {
+			// sb.append(Integer.toHexString(b)).append(" ");
+			// }
+			// logger.debug(sb.toString());
 
-            if (fragmentedFramesText == null) {
-                fragmentedFramesText = new UTF8Output(bytes);
-            } else {
-                fragmentedFramesText.write(bytes);
-            }
-        } catch (UTF8Exception ex) {
-            protocolViolation(channel, "invalid UTF-8 bytes");
-        }
-    }
+			if (fragmentedFramesText == null) {
+				fragmentedFramesText = new UTF8Output(bytes);
+			} else {
+				fragmentedFramesText.write(bytes);
+			}
+		} catch (UTF8Exception ex) {
+			protocolViolation(channel, "invalid UTF-8 bytes");
+		}
+	}
 }
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket08FrameEncoder.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket08FrameEncoder.java
index 00e20db89f..fceeb46f07 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket08FrameEncoder.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket08FrameEncoder.java
@@ -51,123 +51,123 @@ import org.jboss.netty.logging.InternalLoggerFactory;
 
 /**
  * <p>
- * Encodes a web socket frame into wire protocol version 8 format. This code was
- * forked from <a href="https://github.com/joewalnes/webbit">webbit</a> and
- * modified.
+ * Encodes a web socket frame into wire protocol version 8 format. This code was forked from <a
+ * href="https://github.com/joewalnes/webbit">webbit</a> and modified.
  * </p>
  */
 public class WebSocket08FrameEncoder extends OneToOneEncoder {
 
-    private static final InternalLogger logger = InternalLoggerFactory.getInstance(WebSocket08FrameEncoder.class);
+	private static final InternalLogger logger = InternalLoggerFactory.getInstance(WebSocket08FrameEncoder.class);
 
-    private static final byte OPCODE_CONT = 0x0;
-    private static final byte OPCODE_TEXT = 0x1;
-    private static final byte OPCODE_BINARY = 0x2;
-    private static final byte OPCODE_CLOSE = 0x8;
-    private static final byte OPCODE_PING = 0x9;
-    private static final byte OPCODE_PONG = 0xA;
+	private static final byte OPCODE_CONT = 0x0;
+	private static final byte OPCODE_TEXT = 0x1;
+	private static final byte OPCODE_BINARY = 0x2;
+	private static final byte OPCODE_CLOSE = 0x8;
+	private static final byte OPCODE_PING = 0x9;
+	private static final byte OPCODE_PONG = 0xA;
 
-    private boolean maskPayload = false;
+	private boolean maskPayload = false;
 
-    /**
-     * Constructor
-     * 
-     * @param maskPayload
-     *            Web socket clients must set this to true to mask payload.
-     *            Server implementations must set this to false.
-     */
-    public WebSocket08FrameEncoder(boolean maskPayload) {
-        this.maskPayload = maskPayload;
-    }
+	/**
+	 * Constructor
+	 * 
+	 * @param maskPayload
+	 *            Web socket clients must set this to true to mask payload. Server implementations must set this to
+	 *            false.
+	 */
+	public WebSocket08FrameEncoder(boolean maskPayload) {
+		this.maskPayload = maskPayload;
+	}
 
-    @Override
-    protected Object encode(ChannelHandlerContext ctx, Channel channel, Object msg) throws Exception {
+	@Override
+	protected Object encode(ChannelHandlerContext ctx, Channel channel, Object msg) throws Exception {
 
-        byte[] mask = null;
+		byte[] mask = null;
 
-        if (msg instanceof WebSocketFrame) {
-            WebSocketFrame frame = (WebSocketFrame) msg;
-            ChannelBuffer data = frame.getBinaryData();
-            if (data == null) {
-                data = ChannelBuffers.EMPTY_BUFFER;
-            }
+		if (msg instanceof WebSocketFrame) {
+			WebSocketFrame frame = (WebSocketFrame) msg;
+			ChannelBuffer data = frame.getBinaryData();
+			if (data == null) {
+				data = ChannelBuffers.EMPTY_BUFFER;
+			}
 
-            byte opcode;
-            if (frame instanceof TextWebSocketFrame) {
-                opcode = OPCODE_TEXT;
-            } else if (frame instanceof PingWebSocketFrame) {
-                opcode = OPCODE_PING;
-            } else if (frame instanceof PongWebSocketFrame) {
-                opcode = OPCODE_PONG;
-            } else if (frame instanceof CloseWebSocketFrame) {
-                opcode = OPCODE_CLOSE;
-            } else if (frame instanceof BinaryWebSocketFrame) {
-                opcode = OPCODE_BINARY;
-            } else if (frame instanceof ContinuationWebSocketFrame) {
-                opcode = OPCODE_CONT;
-            } else {
-                throw new UnsupportedOperationException("Cannot encode frame of type: " + frame.getClass().getName());
-            }
+			byte opcode;
+			if (frame instanceof TextWebSocketFrame) {
+				opcode = OPCODE_TEXT;
+			} else if (frame instanceof PingWebSocketFrame) {
+				opcode = OPCODE_PING;
+			} else if (frame instanceof PongWebSocketFrame) {
+				opcode = OPCODE_PONG;
+			} else if (frame instanceof CloseWebSocketFrame) {
+				opcode = OPCODE_CLOSE;
+			} else if (frame instanceof BinaryWebSocketFrame) {
+				opcode = OPCODE_BINARY;
+			} else if (frame instanceof ContinuationWebSocketFrame) {
+				opcode = OPCODE_CONT;
+			} else {
+				throw new UnsupportedOperationException("Cannot encode frame of type: " + frame.getClass().getName());
+			}
 
-            int length = data.readableBytes();
+			int length = data.readableBytes();
 
-            if (logger.isDebugEnabled()) {
-            	logger.debug("Encoding WebSocket Frame opCode=" + opcode + " length=" + length);
-            }
-            
-            int b0 = 0;
-            if (frame.isFinalFragment()) {
-                b0 |= (1 << 7);
-            }
-            b0 |= (frame.getRsv() % 8) << 4;
-            b0 |= opcode % 128;
+			if (logger.isDebugEnabled()) {
+				logger.debug("Encoding WebSocket Frame opCode=" + opcode + " length=" + length);
+			}
 
-            ChannelBuffer header;
-            ChannelBuffer body;
+			int b0 = 0;
+			if (frame.isFinalFragment()) {
+				b0 |= (1 << 7);
+			}
+			b0 |= (frame.getRsv() % 8) << 4;
+			b0 |= opcode % 128;
 
-            if (opcode == OPCODE_PING && length > 125) {
-                throw new TooLongFrameException("invalid payload for PING (payload length must be <= 125, was " + length);
-            }
+			ChannelBuffer header;
+			ChannelBuffer body;
 
-            int maskLength = this.maskPayload ? 4 : 0;
-            if (length <= 125) {
-                header = ChannelBuffers.buffer(2 + maskLength);
-                header.writeByte(b0);
-                byte b = (byte) (this.maskPayload ? (0x80 | (byte) length) : (byte) length);
-                header.writeByte(b);
-            } else if (length <= 0xFFFF) {
-                header = ChannelBuffers.buffer(4 + maskLength);
-                header.writeByte(b0);
-                header.writeByte(this.maskPayload ? (0xFE) : 126);
-                header.writeByte((length >>> 8) & 0xFF);
-                header.writeByte((length) & 0xFF);
-            } else {
-                header = ChannelBuffers.buffer(10 + maskLength);
-                header.writeByte(b0);
-                header.writeByte(this.maskPayload ? (0xFF) : 127);
-                header.writeLong(length);
-            }
+			if (opcode == OPCODE_PING && length > 125) {
+				throw new TooLongFrameException("invalid payload for PING (payload length must be <= 125, was "
+						+ length);
+			}
 
-            // Write payload
-            if (this.maskPayload) {
-                Integer random = (int) (Math.random() * Integer.MAX_VALUE);
-                mask = ByteBuffer.allocate(4).putInt(random).array();
-                header.writeBytes(mask);
+			int maskLength = this.maskPayload ? 4 : 0;
+			if (length <= 125) {
+				header = ChannelBuffers.buffer(2 + maskLength);
+				header.writeByte(b0);
+				byte b = (byte) (this.maskPayload ? (0x80 | (byte) length) : (byte) length);
+				header.writeByte(b);
+			} else if (length <= 0xFFFF) {
+				header = ChannelBuffers.buffer(4 + maskLength);
+				header.writeByte(b0);
+				header.writeByte(this.maskPayload ? (0xFE) : 126);
+				header.writeByte((length >>> 8) & 0xFF);
+				header.writeByte((length) & 0xFF);
+			} else {
+				header = ChannelBuffers.buffer(10 + maskLength);
+				header.writeByte(b0);
+				header.writeByte(this.maskPayload ? (0xFF) : 127);
+				header.writeLong(length);
+			}
 
-                body = ChannelBuffers.buffer(length);
-                int counter = 0;
-                while (data.readableBytes() > 0) {
-                    byte byteData = data.readByte();
-                    body.writeByte(byteData ^ mask[+counter++ % 4]);
-                }
-            } else {
-                body = data;
-            }
-            return ChannelBuffers.wrappedBuffer(header, body);
-        }
+			// Write payload
+			if (this.maskPayload) {
+				Integer random = (int) (Math.random() * Integer.MAX_VALUE);
+				mask = ByteBuffer.allocate(4).putInt(random).array();
+				header.writeBytes(mask);
 
-        // If not websocket, then just return the message
-        return msg;
-    }
+				body = ChannelBuffers.buffer(length);
+				int counter = 0;
+				while (data.readableBytes() > 0) {
+					byte byteData = data.readByte();
+					body.writeByte(byteData ^ mask[+counter++ % 4]);
+				}
+			} else {
+				body = data;
+			}
+			return ChannelBuffers.wrappedBuffer(header, body);
+		}
+
+		// If not websocket, then just return the message
+		return msg;
+	}
 
 }
\ No newline at end of file
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket13FrameDecoder.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket13FrameDecoder.java
index 1b6589c820..c8b003fa92 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket13FrameDecoder.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket13FrameDecoder.java
@@ -39,21 +39,20 @@
 package org.jboss.netty.handler.codec.http.websocketx;
 
 /**
- * Decodes a web socket frame from wire protocol version 13 format.
- * V13 is essentially the same as V8.
+ * Decodes a web socket frame from wire protocol version 13 format. V13 is essentially the same as V8.
  */
 public class WebSocket13FrameDecoder extends WebSocket08FrameDecoder {
 
-    /**
-     * Constructor
-     * 
-     * @param maskedPayload
-     *            Web socket servers must set this to true processed incoming
-     *            masked payload. Client implementations must set this to false.
-     * @param allowExtensions
-     *            Flag to allow reserved extension bits to be used or not
-     */
-    public WebSocket13FrameDecoder(boolean maskedPayload, boolean allowExtensions) {
-    	super(maskedPayload, allowExtensions);
-    }
+	/**
+	 * Constructor
+	 * 
+	 * @param maskedPayload
+	 *            Web socket servers must set this to true processed incoming masked payload. Client implementations
+	 *            must set this to false.
+	 * @param allowExtensions
+	 *            Flag to allow reserved extension bits to be used or not
+	 */
+	public WebSocket13FrameDecoder(boolean maskedPayload, boolean allowExtensions) {
+		super(maskedPayload, allowExtensions);
+	}
 }
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket13FrameEncoder.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket13FrameEncoder.java
index 024dbb8b80..43265e831d 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket13FrameEncoder.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocket13FrameEncoder.java
@@ -38,23 +38,21 @@
 
 package org.jboss.netty.handler.codec.http.websocketx;
 
-
 /**
  * <p>
- * Encodes a web socket frame into wire protocol version 13 format. V13 is essentially the same
- * as V8.
+ * Encodes a web socket frame into wire protocol version 13 format. V13 is essentially the same as V8.
  * </p>
  */
 public class WebSocket13FrameEncoder extends WebSocket08FrameEncoder {
 
-    /**
-     * Constructor
-     * 
-     * @param maskPayload
-     *            Web socket clients must set this to true to mask payload.
-     *            Server implementations must set this to false.
-     */
-    public WebSocket13FrameEncoder(boolean maskPayload) {
-        super(maskPayload);
-    }
+	/**
+	 * Constructor
+	 * 
+	 * @param maskPayload
+	 *            Web socket clients must set this to true to mask payload. Server implementations must set this to
+	 *            false.
+	 */
+	public WebSocket13FrameEncoder(boolean maskPayload) {
+		super(maskPayload);
+	}
 }
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketClientHandshaker.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketClientHandshaker.java
index 5c235787c0..090996a54e 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketClientHandshaker.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketClientHandshaker.java
@@ -48,12 +48,10 @@ public abstract class WebSocketClientHandshaker {
 	 * Base constructor
 	 * 
 	 * @param webSocketURL
-	 *            URL for web socket communications. e.g
-	 *            "ws://myhost.com/mypath". Subsequent web socket frames will be
+	 *            URL for web socket communications. e.g "ws://myhost.com/mypath". Subsequent web socket frames will be
 	 *            sent to this URL.
 	 * @param version
-	 *            Version of web socket specification to use to connect to the
-	 *            server
+	 *            Version of web socket specification to use to connect to the server
 	 * @param subProtocol
 	 *            Sub protocol request sent to the server.
 	 * @param customHeaders
@@ -101,8 +99,7 @@ public abstract class WebSocketClientHandshaker {
 	}
 
 	/**
-	 * Returns the sub protocol request sent to the server as specified in the
-	 * constructor
+	 * Returns the sub protocol request sent to the server as specified in the constructor
 	 */
 	public String getSubProtocolRequest() {
 		return subProtocolRequest;
@@ -113,8 +110,7 @@ public abstract class WebSocketClientHandshaker {
 	}
 
 	/**
-	 * Returns the sub protocol response and sent by the server. Only available
-	 * after end of handshake.
+	 * Returns the sub protocol response and sent by the server. Only available after end of handshake.
 	 */
 	public String getSubProtocolResponse() {
 		return subProtocolResponse;
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketClientHandshaker00.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketClientHandshaker00.java
index f3f21df57e..66b40d9833 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketClientHandshaker00.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketClientHandshaker00.java
@@ -35,10 +35,9 @@ import org.jboss.netty.handler.codec.http.HttpVersion;
 
 /**
  * <p>
- * Performs client side opening and closing handshakes for web socket
- * specification version <a
- * href="http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00"
- * >draft-ietf-hybi-thewebsocketprotocol- 00</a>
+ * Performs client side opening and closing handshakes for web socket specification version <a
+ * href="http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00" >draft-ietf-hybi-thewebsocketprotocol-
+ * 00</a>
  * </p>
  * <p>
  * A very large portion of this code was taken from the Netty 3.2 HTTP example.
@@ -49,16 +48,13 @@ public class WebSocketClientHandshaker00 extends WebSocketClientHandshaker {
 	private byte[] expectedChallengeResponseBytes = null;
 
 	/**
-	 * Constructor specifying the destination web socket location and version to
-	 * initiate
+	 * Constructor specifying the destination web socket location and version to initiate
 	 * 
 	 * @param webSocketURL
-	 *            URL for web socket communications. e.g
-	 *            "ws://myhost.com/mypath". Subsequent web socket frames will be
+	 *            URL for web socket communications. e.g "ws://myhost.com/mypath". Subsequent web socket frames will be
 	 *            sent to this URL.
 	 * @param version
-	 *            Version of web socket specification to use to connect to the
-	 *            server
+	 *            Version of web socket specification to use to connect to the server
 	 * @param subProtocol
 	 *            Sub protocol request sent to the server.
 	 * @param customHeaders
@@ -177,8 +173,7 @@ public class WebSocketClientHandshaker00 extends WebSocketClientHandshaker {
 	 * @param channel
 	 *            Channel
 	 * @param response
-	 *            HTTP response returned from the server for the request sent by
-	 *            beginOpeningHandshake00().
+	 *            HTTP response returned from the server for the request sent by beginOpeningHandshake00().
 	 * @throws WebSocketHandshakeException
 	 */
 	@Override
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketClientHandshaker08.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketClientHandshaker08.java
index 62bfbc7fef..45af4ddaf9 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketClientHandshaker08.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketClientHandshaker08.java
@@ -35,10 +35,9 @@ import org.jboss.netty.util.CharsetUtil;
 
 /**
  * <p>
- * Performs client side opening and closing handshakes for web socket
- * specification version <a
- * href="http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-10"
- * >draft-ietf-hybi-thewebsocketprotocol- 10</a>
+ * Performs client side opening and closing handshakes for web socket specification version <a
+ * href="http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-10" >draft-ietf-hybi-thewebsocketprotocol-
+ * 10</a>
  * </p>
  */
 public class WebSocketClientHandshaker08 extends WebSocketClientHandshaker {
@@ -54,21 +53,17 @@ public class WebSocketClientHandshaker08 extends WebSocketClientHandshaker {
 	private boolean allowExtensions = false;
 
 	/**
-	 * Constructor specifying the destination web socket location and version to
-	 * initiate
+	 * Constructor specifying the destination web socket location and version to initiate
 	 * 
 	 * @param webSocketURL
-	 *            URL for web socket communications. e.g
-	 *            "ws://myhost.com/mypath". Subsequent web socket frames will be
+	 *            URL for web socket communications. e.g "ws://myhost.com/mypath". Subsequent web socket frames will be
 	 *            sent to this URL.
 	 * @param version
-	 *            Version of web socket specification to use to connect to the
-	 *            server
+	 *            Version of web socket specification to use to connect to the server
 	 * @param subProtocol
 	 *            Sub protocol request sent to the server.
 	 * @param allowExtensions
-	 *            Allow extensions to be used in the reserved bits of the web
-	 *            socket frame
+	 *            Allow extensions to be used in the reserved bits of the web socket frame
 	 * @param customHeaders
 	 *            Map of custom headers to add to the client request
 	 */
@@ -158,8 +153,7 @@ public class WebSocketClientHandshaker08 extends WebSocketClientHandshaker {
 	 * @param channel
 	 *            Channel
 	 * @param response
-	 *            HTTP response returned from the server for the request sent by
-	 *            beginOpeningHandshake00().
+	 *            HTTP response returned from the server for the request sent by beginOpeningHandshake00().
 	 * @throws WebSocketHandshakeException
 	 */
 	@Override
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketClientHandshaker13.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketClientHandshaker13.java
index d7dc30267f..dc172d14ef 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketClientHandshaker13.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketClientHandshaker13.java
@@ -35,9 +35,8 @@ import org.jboss.netty.util.CharsetUtil;
 
 /**
  * <p>
- * Performs client side opening and closing handshakes for <a
- * href="http://tools.ietf.org/html/rfc6455">RFC 6455</a>. This was originally
- * <a href="http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17"
+ * Performs client side opening and closing handshakes for <a href="http://tools.ietf.org/html/rfc6455">RFC 6455</a>.
+ * This was originally <a href="http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17"
  * >draft-ietf-hybi-thewebsocketprotocol- 17</a>
  * </p>
  */
@@ -54,21 +53,17 @@ public class WebSocketClientHandshaker13 extends WebSocketClientHandshaker {
 	private boolean allowExtensions = false;
 
 	/**
-	 * Constructor specifying the destination web socket location and version to
-	 * initiate
+	 * Constructor specifying the destination web socket location and version to initiate
 	 * 
 	 * @param webSocketURL
-	 *            URL for web socket communications. e.g
-	 *            "ws://myhost.com/mypath". Subsequent web socket frames will be
+	 *            URL for web socket communications. e.g "ws://myhost.com/mypath". Subsequent web socket frames will be
 	 *            sent to this URL.
 	 * @param version
-	 *            Version of web socket specification to use to connect to the
-	 *            server
+	 *            Version of web socket specification to use to connect to the server
 	 * @param subProtocol
 	 *            Sub protocol request sent to the server.
 	 * @param allowExtensions
-	 *            Allow extensions to be used in the reserved bits of the web
-	 *            socket frame
+	 *            Allow extensions to be used in the reserved bits of the web socket frame
 	 * @param customHeaders
 	 *            Map of custom headers to add to the client request
 	 */
@@ -158,8 +153,7 @@ public class WebSocketClientHandshaker13 extends WebSocketClientHandshaker {
 	 * @param channel
 	 *            Channel
 	 * @param response
-	 *            HTTP response returned from the server for the request sent by
-	 *            beginOpeningHandshake00().
+	 *            HTTP response returned from the server for the request sent by beginOpeningHandshake00().
 	 * @throws WebSocketHandshakeException
 	 */
 	@Override
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketClientHandshakerFactory.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketClientHandshakerFactory.java
index 6ec12a3393..66aa931d8d 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketClientHandshakerFactory.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketClientHandshakerFactory.java
@@ -27,18 +27,14 @@ public class WebSocketClientHandshakerFactory {
 	 * Instances a new handshaker
 	 * 
 	 * @param webSocketURL
-	 *            URL for web socket communications. e.g
-	 *            "ws://myhost.com/mypath". Subsequent web socket frames will be
+	 *            URL for web socket communications. e.g "ws://myhost.com/mypath". Subsequent web socket frames will be
 	 *            sent to this URL.
 	 * @param version
-	 *            Version of web socket specification to use to connect to the
-	 *            server
+	 *            Version of web socket specification to use to connect to the server
 	 * @param subProtocol
-	 *            Sub protocol request sent to the server. Null if no
-	 *            sub-protocol support is required.
+	 *            Sub protocol request sent to the server. Null if no sub-protocol support is required.
 	 * @param allowExtensions
-	 *            Allow extensions to be used in the reserved bits of the web
-	 *            socket frame
+	 *            Allow extensions to be used in the reserved bits of the web socket frame
 	 * @param customHeaders
 	 *            custom HTTP headers
 	 * @throws WebSocketHandshakeException
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketFrame.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketFrame.java
index d99312f6c8..f04a4302ce 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketFrame.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketFrame.java
@@ -22,57 +22,57 @@ import org.jboss.netty.buffer.ChannelBuffer;
  */
 public abstract class WebSocketFrame {
 
-    /**
-     * Flag to indicate if this frame is the final fragment in a message. The
-     * first fragment (frame) may also be the final fragment.
-     */
-    private boolean finalFragment = true;
+	/**
+	 * Flag to indicate if this frame is the final fragment in a message. The first fragment (frame) may also be the
+	 * final fragment.
+	 */
+	private boolean finalFragment = true;
 
-    /**
-     * RSV1, RSV2, RSV3 used for extensions
-     */
-    private int rsv = 0;
+	/**
+	 * RSV1, RSV2, RSV3 used for extensions
+	 */
+	private int rsv = 0;
 
-    /**
-     * Contents of this frame
-     */
-    private ChannelBuffer binaryData;
+	/**
+	 * Contents of this frame
+	 */
+	private ChannelBuffer binaryData;
 
-    /**
-     * Returns binary data
-     */
-    public ChannelBuffer getBinaryData() {
-        return binaryData;
-    }
+	/**
+	 * Returns binary data
+	 */
+	public ChannelBuffer getBinaryData() {
+		return binaryData;
+	}
 
-    /**
-     * Sets the binary data for this frame
-     */
-    public void setBinaryData(ChannelBuffer binaryData) {
-        this.binaryData = binaryData;
-    }
+	/**
+	 * Sets the binary data for this frame
+	 */
+	public void setBinaryData(ChannelBuffer binaryData) {
+		this.binaryData = binaryData;
+	}
 
-    /**
-     * Flag to indicate if this frame is the final fragment in a message. The
-     * first fragment (frame) may also be the final fragment.
-     */
-    public boolean isFinalFragment() {
-        return finalFragment;
-    }
+	/**
+	 * Flag to indicate if this frame is the final fragment in a message. The first fragment (frame) may also be the
+	 * final fragment.
+	 */
+	public boolean isFinalFragment() {
+		return finalFragment;
+	}
 
-    public void setFinalFragment(boolean finalFragment) {
-        this.finalFragment = finalFragment;
-    }
+	public void setFinalFragment(boolean finalFragment) {
+		this.finalFragment = finalFragment;
+	}
 
-    /**
-     * Bits used for extensions to the standard.
-     */
-    public int getRsv() {
-        return rsv;
-    }
+	/**
+	 * Bits used for extensions to the standard.
+	 */
+	public int getRsv() {
+		return rsv;
+	}
 
-    public void setRsv(int rsv) {
-        this.rsv = rsv;
-    }
+	public void setRsv(int rsv) {
+		this.rsv = rsv;
+	}
 
 }
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketFrameType.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketFrameType.java
index 8e67a5e73b..a82fc3b953 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketFrameType.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketFrameType.java
@@ -19,5 +19,5 @@ package org.jboss.netty.handler.codec.http.websocketx;
  * Type of web socket frames
  */
 public enum WebSocketFrameType {
-    TEXT, BINARY, PING, PONG, CLOSE, CONTINUATION
+	TEXT, BINARY, PING, PONG, CLOSE, CONTINUATION
 }
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketHandshakeException.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketHandshakeException.java
index 5356ac14ef..9f04b40613 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketHandshakeException.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketHandshakeException.java
@@ -20,13 +20,13 @@ package org.jboss.netty.handler.codec.http.websocketx;
  */
 public class WebSocketHandshakeException extends Exception {
 
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
 
-    public WebSocketHandshakeException(String s) {
-        super(s);
-    }
+	public WebSocketHandshakeException(String s) {
+		super(s);
+	}
 
-    public WebSocketHandshakeException(String s, Throwable throwable) {
-        super(s, throwable);
-    }
+	public WebSocketHandshakeException(String s, Throwable throwable) {
+		super(s, throwable);
+	}
 }
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketServerHandshaker.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketServerHandshaker.java
index f0cd27eaa0..458f8610e7 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketServerHandshaker.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketServerHandshaker.java
@@ -27,159 +27,157 @@ import org.jboss.netty.util.CharsetUtil;
 
 public abstract class WebSocketServerHandshaker {
 
-    private String webSocketURL;
+	private String webSocketURL;
 
-    private String subProtocols;
+	private String subProtocols;
 
-    private String[] subProtocolsArray = null;
+	private String[] subProtocolsArray = null;
 
-    private WebSocketVersion version = WebSocketVersion.UNKNOWN;
+	private WebSocketVersion version = WebSocketVersion.UNKNOWN;
 
-    /**
-     * Constructor specifying the destination web socket location
-     *
-     * @param webSocketURL
-     *            URL for web socket communications. e.g
-     *            "ws://myhost.com/mypath". Subsequent web socket frames will be
-     *            sent to this URL.
-     * @param subProtocols
-     *            CSV of supported protocols. Null if sub protocols not
-     *            supported.
-     */
-    public WebSocketServerHandshaker(String webSocketURL, String subProtocols) {
-        this.webSocketURL = webSocketURL;
-        this.subProtocols = subProtocols;
+	/**
+	 * Constructor specifying the destination web socket location
+	 * 
+	 * @param webSocketURL
+	 *            URL for web socket communications. e.g "ws://myhost.com/mypath". Subsequent web socket frames will be
+	 *            sent to this URL.
+	 * @param subProtocols
+	 *            CSV of supported protocols. Null if sub protocols not supported.
+	 */
+	public WebSocketServerHandshaker(String webSocketURL, String subProtocols) {
+		this.webSocketURL = webSocketURL;
+		this.subProtocols = subProtocols;
 
-        if (this.subProtocols != null) {
-            this.subProtocolsArray = subProtocols.split(",");
-            for (int i = 0; i < this.subProtocolsArray.length; i++) {
-                this.subProtocolsArray[i] = this.subProtocolsArray[i].trim();
-            }
-        }
-    }
+		if (this.subProtocols != null) {
+			this.subProtocolsArray = subProtocols.split(",");
+			for (int i = 0; i < this.subProtocolsArray.length; i++) {
+				this.subProtocolsArray[i] = this.subProtocolsArray[i].trim();
+			}
+		}
+	}
 
-    /**
-     * Returns the URL of the web socket
-     */
-    public String getWebSocketURL() {
-        return webSocketURL;
-    }
+	/**
+	 * Returns the URL of the web socket
+	 */
+	public String getWebSocketURL() {
+		return webSocketURL;
+	}
 
-    public void setWebSocketURL(String webSocketURL) {
-        this.webSocketURL = webSocketURL;
-    }
+	public void setWebSocketURL(String webSocketURL) {
+		this.webSocketURL = webSocketURL;
+	}
 
-    /**
-     * Returns the CSV of supported sub protocols
-     */
-    public String getSubProtocols() {
-        return subProtocols;
-    }
+	/**
+	 * Returns the CSV of supported sub protocols
+	 */
+	public String getSubProtocols() {
+		return subProtocols;
+	}
 
-    public void setSubProtocols(String subProtocols) {
-        this.subProtocols = subProtocols;
-    }
+	public void setSubProtocols(String subProtocols) {
+		this.subProtocols = subProtocols;
+	}
 
-    /**
-     * Returns the version of the specification being supported
-     */
-    public WebSocketVersion getVersion() {
-        return version;
-    }
+	/**
+	 * Returns the version of the specification being supported
+	 */
+	public WebSocketVersion getVersion() {
+		return version;
+	}
 
-    public void setVersion(WebSocketVersion version) {
-        this.version = version;
-    }
+	public void setVersion(WebSocketVersion version) {
+		this.version = version;
+	}
 
-    /**
-     * Performs the opening handshake
-     *
-     * @param channel
-     *            Channel
-     * @param req
-     *            HTTP Request
-     * @throws NoSuchAlgorithmException
-     */
-    public abstract void performOpeningHandshake(Channel channel, HttpRequest req);
+	/**
+	 * Performs the opening handshake
+	 * 
+	 * @param channel
+	 *            Channel
+	 * @param req
+	 *            HTTP Request
+	 * @throws NoSuchAlgorithmException
+	 */
+	public abstract void performOpeningHandshake(Channel channel, HttpRequest req);
 
-    /**
-     * Performs the closing handshake
-     *
-     * @param channel
-     *            Channel
-     * @param frame
-     *            Closing Frame that was received
-     */
-    public abstract void performClosingHandshake(Channel channel, CloseWebSocketFrame frame);
+	/**
+	 * Performs the closing handshake
+	 * 
+	 * @param channel
+	 *            Channel
+	 * @param frame
+	 *            Closing Frame that was received
+	 */
+	public abstract void performClosingHandshake(Channel channel, CloseWebSocketFrame frame);
 
-    /**
-     * Performs an MD5 hash
-     *
-     * @param bytes
-     *            Data to hash
-     * @return Hashed data
-     */
-    protected byte[] md5(byte[] bytes) {
-        try {
-            MessageDigest md = MessageDigest.getInstance("MD5");
-            return md.digest(bytes);
-        } catch (NoSuchAlgorithmException e) {
-            throw new InternalError("MD5 not supported on this platform");
-        }
-    }
+	/**
+	 * Performs an MD5 hash
+	 * 
+	 * @param bytes
+	 *            Data to hash
+	 * @return Hashed data
+	 */
+	protected byte[] md5(byte[] bytes) {
+		try {
+			MessageDigest md = MessageDigest.getInstance("MD5");
+			return md.digest(bytes);
+		} catch (NoSuchAlgorithmException e) {
+			throw new InternalError("MD5 not supported on this platform");
+		}
+	}
 
-    /**
-     * SHA-1 hashing. Instance this we think it is not thread safe
-     *
-     * @param bytes
-     *            byte to hash
-     * @return hashed
-     */
-    protected byte[] sha1(byte[] bytes) {
-        try {
-            MessageDigest md = MessageDigest.getInstance("SHA1");
-            return md.digest(bytes);
-        } catch (NoSuchAlgorithmException e) {
-            throw new InternalError("SHA-1 not supported on this platform");
-        }
-    }
+	/**
+	 * SHA-1 hashing. Instance this we think it is not thread safe
+	 * 
+	 * @param bytes
+	 *            byte to hash
+	 * @return hashed
+	 */
+	protected byte[] sha1(byte[] bytes) {
+		try {
+			MessageDigest md = MessageDigest.getInstance("SHA1");
+			return md.digest(bytes);
+		} catch (NoSuchAlgorithmException e) {
+			throw new InternalError("SHA-1 not supported on this platform");
+		}
+	}
 
-    /**
-     * Base 64 encoding
-     *
-     * @param bytes
-     *            Bytes to encode
-     * @return encoded string
-     */
-    protected String base64Encode(byte[] bytes) {
-        ChannelBuffer hashed = ChannelBuffers.wrappedBuffer(bytes);
-        return Base64.encode(hashed).toString(CharsetUtil.UTF_8);
-    }
+	/**
+	 * Base 64 encoding
+	 * 
+	 * @param bytes
+	 *            Bytes to encode
+	 * @return encoded string
+	 */
+	protected String base64Encode(byte[] bytes) {
+		ChannelBuffer hashed = ChannelBuffers.wrappedBuffer(bytes);
+		return Base64.encode(hashed).toString(CharsetUtil.UTF_8);
+	}
 
-    /**
-     * Selects the first matching supported sub protocol
-     *
-     * @param requestedSubProtocol
-     *            CSV of protocols to be supported. e.g. "chat, superchat"
-     * @return First matching supported sub protocol. Null if not found.
-     */
-    protected String selectSubProtocol(String requestedSubProtocol) {
-        if (requestedSubProtocol == null || this.subProtocolsArray == null) {
-            return null;
-        }
+	/**
+	 * Selects the first matching supported sub protocol
+	 * 
+	 * @param requestedSubProtocol
+	 *            CSV of protocols to be supported. e.g. "chat, superchat"
+	 * @return First matching supported sub protocol. Null if not found.
+	 */
+	protected String selectSubProtocol(String requestedSubProtocol) {
+		if (requestedSubProtocol == null || this.subProtocolsArray == null) {
+			return null;
+		}
 
-        String[] requesteSubProtocolsArray = requestedSubProtocol.split(",");
-        for (int i = 0; i < requesteSubProtocolsArray.length; i++) {
-            String requesteSubProtocol = requesteSubProtocolsArray[i].trim();
+		String[] requesteSubProtocolsArray = requestedSubProtocol.split(",");
+		for (int i = 0; i < requesteSubProtocolsArray.length; i++) {
+			String requesteSubProtocol = requesteSubProtocolsArray[i].trim();
 
-            for (String supportedSubProtocol : this.subProtocolsArray) {
-                if (requesteSubProtocol.equals(supportedSubProtocol)) {
-                    return requesteSubProtocol;
-                }
-            }
-        }
+			for (String supportedSubProtocol : this.subProtocolsArray) {
+				if (requesteSubProtocol.equals(supportedSubProtocol)) {
+					return requesteSubProtocol;
+				}
+			}
+		}
 
-        // No match found
-        return null;
-    }
+		// No match found
+		return null;
+	}
 }
\ No newline at end of file
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketServerHandshaker00.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketServerHandshaker00.java
index 2a8fde99db..fa79b6adbb 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketServerHandshaker00.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketServerHandshaker00.java
@@ -48,10 +48,9 @@ import org.jboss.netty.logging.InternalLoggerFactory;
 
 /**
  * <p>
- * Performs server side opening and closing handshakes for web socket
- * specification version <a
- * href="http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00"
- * >draft-ietf-hybi-thewebsocketprotocol- 00</a>
+ * Performs server side opening and closing handshakes for web socket specification version <a
+ * href="http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00" >draft-ietf-hybi-thewebsocketprotocol-
+ * 00</a>
  * </p>
  * <p>
  * A very large portion of this code was taken from the Netty 3.2 HTTP example.
@@ -59,143 +58,141 @@ import org.jboss.netty.logging.InternalLoggerFactory;
  */
 public class WebSocketServerHandshaker00 extends WebSocketServerHandshaker {
 
-    private static final InternalLogger logger = InternalLoggerFactory.getInstance(WebSocketServerHandshaker00.class);
+	private static final InternalLogger logger = InternalLoggerFactory.getInstance(WebSocketServerHandshaker00.class);
 
-    /**
-     * Constructor specifying the destination web socket location
-     *
-     * @param webSocketURL
-     *            URL for web socket communications. e.g
-     *            "ws://myhost.com/mypath". Subsequent web socket frames will be
-     *            sent to this URL.
-     * @param subProtocols
-     *            CSV of supported protocols
-     */
-    public WebSocketServerHandshaker00(String webSocketURL, String subProtocols) {
-        super(webSocketURL, subProtocols);
-    }
+	/**
+	 * Constructor specifying the destination web socket location
+	 * 
+	 * @param webSocketURL
+	 *            URL for web socket communications. e.g "ws://myhost.com/mypath". Subsequent web socket frames will be
+	 *            sent to this URL.
+	 * @param subProtocols
+	 *            CSV of supported protocols
+	 */
+	public WebSocketServerHandshaker00(String webSocketURL, String subProtocols) {
+		super(webSocketURL, subProtocols);
+	}
 
-    /**
-     * <p>
-     * Handle the web socket handshake for the web socket specification <a href=
-     * "http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00">HyBi
-     * version 0</a> and lower. This standard is really a rehash of <a
-     * href="http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76"
-     * >hixie-76</a> and <a
-     * href="http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75"
-     * >hixie-75</a>.
-     * </p>
-     *
-     * <p>
-     * Browser request to the server:
-     * </p>
-     *
-     * <pre>
-     * GET /demo HTTP/1.1
-     * Upgrade: WebSocket
-     * Connection: Upgrade
-     * Host: example.com
-     * Origin: http://example.com
-     * Sec-WebSocket-Key1: 4 @1  46546xW%0l 1 5
-     * Sec-WebSocket-Key2: 12998 5 Y3 1  .P00
-     *
-     * ^n:ds[4U
-     * </pre>
-     *
-     * <p>
-     * Server response:
-     * </p>
-     *
-     * <pre>
-     * HTTP/1.1 101 WebSocket Protocol Handshake
-     * Upgrade: WebSocket
-     * Connection: Upgrade
-     * Sec-WebSocket-Origin: http://example.com
-     * Sec-WebSocket-Location: ws://example.com/demo
-     * Sec-WebSocket-Protocol: sample
-     *
-     * 8jKS'y:G*Co,Wxa-
-     * </pre>
-     *
-     * @param channel
-     *            Channel
-     * @param req
-     *            HTTP request
-     * @throws NoSuchAlgorithmException
-     */
-    @Override
-    public void performOpeningHandshake(Channel channel, HttpRequest req) {
+	/**
+	 * <p>
+	 * Handle the web socket handshake for the web socket specification <a href=
+	 * "http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00">HyBi version 0</a> and lower. This standard
+	 * is really a rehash of <a href="http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76" >hixie-76</a> and
+	 * <a href="http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75" >hixie-75</a>.
+	 * </p>
+	 * 
+	 * <p>
+	 * Browser request to the server:
+	 * </p>
+	 * 
+	 * <pre>
+	 * GET /demo HTTP/1.1
+	 * Upgrade: WebSocket
+	 * Connection: Upgrade
+	 * Host: example.com
+	 * Origin: http://example.com
+	 * Sec-WebSocket-Key1: 4 @1  46546xW%0l 1 5
+	 * Sec-WebSocket-Key2: 12998 5 Y3 1  .P00
+	 * 
+	 * ^n:ds[4U
+	 * </pre>
+	 * 
+	 * <p>
+	 * Server response:
+	 * </p>
+	 * 
+	 * <pre>
+	 * HTTP/1.1 101 WebSocket Protocol Handshake
+	 * Upgrade: WebSocket
+	 * Connection: Upgrade
+	 * Sec-WebSocket-Origin: http://example.com
+	 * Sec-WebSocket-Location: ws://example.com/demo
+	 * Sec-WebSocket-Protocol: sample
+	 * 
+	 * 8jKS'y:G*Co,Wxa-
+	 * </pre>
+	 * 
+	 * @param channel
+	 *            Channel
+	 * @param req
+	 *            HTTP request
+	 * @throws NoSuchAlgorithmException
+	 */
+	@Override
+	public void performOpeningHandshake(Channel channel, HttpRequest req) {
 
-        if (logger.isDebugEnabled()) {
-            logger.debug(String.format("Channel %s web socket spec version 00 handshake", channel.getId()));
-        }
-        this.setVersion(WebSocketVersion.V00);
+		if (logger.isDebugEnabled()) {
+			logger.debug(String.format("Channel %s web socket spec version 00 handshake", channel.getId()));
+		}
+		this.setVersion(WebSocketVersion.V00);
 
-        // Serve the WebSocket handshake request.
-        if (!Values.UPGRADE.equalsIgnoreCase(req.getHeader(CONNECTION)) || !WEBSOCKET.equalsIgnoreCase(req.getHeader(Names.UPGRADE))) {
-            return;
-        }
+		// Serve the WebSocket handshake request.
+		if (!Values.UPGRADE.equalsIgnoreCase(req.getHeader(CONNECTION))
+				|| !WEBSOCKET.equalsIgnoreCase(req.getHeader(Names.UPGRADE))) {
+			return;
+		}
 
-        // Hixie 75 does not contain these headers while Hixie 76 does
-        boolean isHixie76 = req.containsHeader(SEC_WEBSOCKET_KEY1) && req.containsHeader(SEC_WEBSOCKET_KEY2);
+		// Hixie 75 does not contain these headers while Hixie 76 does
+		boolean isHixie76 = req.containsHeader(SEC_WEBSOCKET_KEY1) && req.containsHeader(SEC_WEBSOCKET_KEY2);
 
-        // Create the WebSocket handshake response.
-        HttpResponse res = new DefaultHttpResponse(HTTP_1_1, new HttpResponseStatus(101, isHixie76 ? "WebSocket Protocol Handshake" : "Web Socket Protocol Handshake"));
-        res.addHeader(Names.UPGRADE, WEBSOCKET);
-        res.addHeader(CONNECTION, Values.UPGRADE);
+		// Create the WebSocket handshake response.
+		HttpResponse res = new DefaultHttpResponse(HTTP_1_1, new HttpResponseStatus(101,
+				isHixie76 ? "WebSocket Protocol Handshake" : "Web Socket Protocol Handshake"));
+		res.addHeader(Names.UPGRADE, WEBSOCKET);
+		res.addHeader(CONNECTION, Values.UPGRADE);
 
-        // Fill in the headers and contents depending on handshake method.
-        if (isHixie76) {
-            // New handshake method with a challenge:
-            res.addHeader(SEC_WEBSOCKET_ORIGIN, req.getHeader(ORIGIN));
-            res.addHeader(SEC_WEBSOCKET_LOCATION, this.getWebSocketURL());
-            String protocol = req.getHeader(SEC_WEBSOCKET_PROTOCOL);
-            if (protocol != null) {
-                res.addHeader(SEC_WEBSOCKET_PROTOCOL, selectSubProtocol(protocol));
-            }
+		// Fill in the headers and contents depending on handshake method.
+		if (isHixie76) {
+			// New handshake method with a challenge:
+			res.addHeader(SEC_WEBSOCKET_ORIGIN, req.getHeader(ORIGIN));
+			res.addHeader(SEC_WEBSOCKET_LOCATION, this.getWebSocketURL());
+			String protocol = req.getHeader(SEC_WEBSOCKET_PROTOCOL);
+			if (protocol != null) {
+				res.addHeader(SEC_WEBSOCKET_PROTOCOL, selectSubProtocol(protocol));
+			}
 
-            // Calculate the answer of the challenge.
-            String key1 = req.getHeader(SEC_WEBSOCKET_KEY1);
-            String key2 = req.getHeader(SEC_WEBSOCKET_KEY2);
-            int a = (int) (Long.parseLong(key1.replaceAll("[^0-9]", "")) / key1.replaceAll("[^ ]", "").length());
-            int b = (int) (Long.parseLong(key2.replaceAll("[^0-9]", "")) / key2.replaceAll("[^ ]", "").length());
-            long c = req.getContent().readLong();
-            ChannelBuffer input = ChannelBuffers.buffer(16);
-            input.writeInt(a);
-            input.writeInt(b);
-            input.writeLong(c);
-            ChannelBuffer output = ChannelBuffers.wrappedBuffer(this.md5(input.array()));
-            res.setContent(output);
-        } else {
-            // Old Hixie 75 handshake method with no challenge:
-            res.addHeader(WEBSOCKET_ORIGIN, req.getHeader(ORIGIN));
-            res.addHeader(WEBSOCKET_LOCATION, this.getWebSocketURL());
-            String protocol = req.getHeader(WEBSOCKET_PROTOCOL);
-            if (protocol != null) {
-                res.addHeader(WEBSOCKET_PROTOCOL, selectSubProtocol(protocol));
-            }
-        }
+			// Calculate the answer of the challenge.
+			String key1 = req.getHeader(SEC_WEBSOCKET_KEY1);
+			String key2 = req.getHeader(SEC_WEBSOCKET_KEY2);
+			int a = (int) (Long.parseLong(key1.replaceAll("[^0-9]", "")) / key1.replaceAll("[^ ]", "").length());
+			int b = (int) (Long.parseLong(key2.replaceAll("[^0-9]", "")) / key2.replaceAll("[^ ]", "").length());
+			long c = req.getContent().readLong();
+			ChannelBuffer input = ChannelBuffers.buffer(16);
+			input.writeInt(a);
+			input.writeInt(b);
+			input.writeLong(c);
+			ChannelBuffer output = ChannelBuffers.wrappedBuffer(this.md5(input.array()));
+			res.setContent(output);
+		} else {
+			// Old Hixie 75 handshake method with no challenge:
+			res.addHeader(WEBSOCKET_ORIGIN, req.getHeader(ORIGIN));
+			res.addHeader(WEBSOCKET_LOCATION, this.getWebSocketURL());
+			String protocol = req.getHeader(WEBSOCKET_PROTOCOL);
+			if (protocol != null) {
+				res.addHeader(WEBSOCKET_PROTOCOL, selectSubProtocol(protocol));
+			}
+		}
 
-        // Upgrade the connection and send the handshake response.
-        ChannelPipeline p = channel.getPipeline();
-        p.remove(HttpChunkAggregator.class);
-        p.replace(HttpRequestDecoder.class, "wsdecoder", new WebSocket00FrameDecoder());
+		// Upgrade the connection and send the handshake response.
+		ChannelPipeline p = channel.getPipeline();
+		p.remove(HttpChunkAggregator.class);
+		p.replace(HttpRequestDecoder.class, "wsdecoder", new WebSocket00FrameDecoder());
 
-        channel.write(res);
+		channel.write(res);
 
-        p.replace(HttpResponseEncoder.class, "wsencoder", new WebSocket00FrameEncoder());
-    }
+		p.replace(HttpResponseEncoder.class, "wsencoder", new WebSocket00FrameEncoder());
+	}
 
-    /**
-     * Echo back the closing frame
-     *
-     * @param channel
-     *            Channel
-     * @param frame
-     *            Web Socket frame that was received
-     */
-    @Override
-    public void performClosingHandshake(Channel channel, CloseWebSocketFrame frame) {
-        channel.write(frame);
-    }
+	/**
+	 * Echo back the closing frame
+	 * 
+	 * @param channel
+	 *            Channel
+	 * @param frame
+	 *            Web Socket frame that was received
+	 */
+	@Override
+	public void performClosingHandshake(Channel channel, CloseWebSocketFrame frame) {
+		channel.write(frame);
+	}
 }
\ No newline at end of file
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketServerHandshaker08.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketServerHandshaker08.java
index 4acab1b4bd..283e3d7c45 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketServerHandshaker08.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketServerHandshaker08.java
@@ -38,16 +38,14 @@ import org.jboss.netty.util.CharsetUtil;
 
 /**
  * <p>
- * Performs server side opening and closing handshakes for web socket
- * specification version <a
- * href="http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-10"
- * >draft-ietf-hybi-thewebsocketprotocol- 10</a>
+ * Performs server side opening and closing handshakes for web socket specification version <a
+ * href="http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-10" >draft-ietf-hybi-thewebsocketprotocol-
+ * 10</a>
  * </p>
  */
 public class WebSocketServerHandshaker08 extends WebSocketServerHandshaker {
 
-	private static final InternalLogger logger = InternalLoggerFactory
-			.getInstance(WebSocketServerHandshaker08.class);
+	private static final InternalLogger logger = InternalLoggerFactory.getInstance(WebSocketServerHandshaker08.class);
 
 	public static final String WEBSOCKET_08_ACCEPT_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 
@@ -57,17 +55,14 @@ public class WebSocketServerHandshaker08 extends WebSocketServerHandshaker {
 	 * Constructor specifying the destination web socket location
 	 * 
 	 * @param webSocketURL
-	 *            URL for web socket communications. e.g
-	 *            "ws://myhost.com/mypath". Subsequent web socket frames will be
+	 *            URL for web socket communications. e.g "ws://myhost.com/mypath". Subsequent web socket frames will be
 	 *            sent to this URL.
 	 * @param subProtocols
 	 *            CSV of supported protocols
 	 * @param allowExtensions
-	 *            Allow extensions to be used in the reserved bits of the web
-	 *            socket frame
+	 *            Allow extensions to be used in the reserved bits of the web socket frame
 	 */
-	public WebSocketServerHandshaker08(String webSocketURL,
-			String subProtocols, boolean allowExtensions) {
+	public WebSocketServerHandshaker08(String webSocketURL, String subProtocols, boolean allowExtensions) {
 		super(webSocketURL, subProtocols);
 		this.allowExtensions = allowExtensions;
 	}
@@ -75,8 +70,8 @@ public class WebSocketServerHandshaker08 extends WebSocketServerHandshaker {
 	/**
 	 * <p>
 	 * Handle the web socket handshake for the web socket specification <a href=
-	 * "http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-08">HyBi
-	 * version 8 to 10</a>. Version 8, 9 and 10 share the same wire protocol.
+	 * "http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-08">HyBi version 8 to 10</a>. Version 8, 9 and
+	 * 10 share the same wire protocol.
 	 * </p>
 	 * 
 	 * <p>
@@ -116,13 +111,10 @@ public class WebSocketServerHandshaker08 extends WebSocketServerHandshaker {
 	public void performOpeningHandshake(Channel channel, HttpRequest req) {
 
 		if (logger.isDebugEnabled()) {
-			logger.debug(String.format(
-					"Channel %s WS version 08 handshake",
-					channel.getId()));
+			logger.debug(String.format("Channel %s WS version 08 handshake", channel.getId()));
 		}
 
-		HttpResponse res = new DefaultHttpResponse(HTTP_1_1,
-				new HttpResponseStatus(101, "Switching Protocols"));
+		HttpResponse res = new DefaultHttpResponse(HTTP_1_1, new HttpResponseStatus(101, "Switching Protocols"));
 		this.setVersion(WebSocketVersion.V08);
 
 		String key = req.getHeader(Names.SEC_WEBSOCKET_KEY);
@@ -135,9 +127,7 @@ public class WebSocketServerHandshaker08 extends WebSocketServerHandshaker {
 		String accept = base64Encode(sha1);
 
 		if (logger.isDebugEnabled()) {
-			logger.debug(String.format(
-					"WS Version 08 Server Handshake key: %s. Response: %s.",
-					key, accept));
+			logger.debug(String.format("WS Version 08 Server Handshake key: %s. Response: %s.", key, accept));
 		}
 
 		res.setStatus(new HttpResponseStatus(101, "Switching Protocols"));
@@ -146,8 +136,7 @@ public class WebSocketServerHandshaker08 extends WebSocketServerHandshaker {
 		res.addHeader(Names.SEC_WEBSOCKET_ACCEPT, accept);
 		String protocol = req.getHeader(Names.SEC_WEBSOCKET_PROTOCOL);
 		if (protocol != null) {
-			res.addHeader(Names.SEC_WEBSOCKET_PROTOCOL,
-					this.selectSubProtocol(protocol));
+			res.addHeader(Names.SEC_WEBSOCKET_PROTOCOL, this.selectSubProtocol(protocol));
 		}
 
 		channel.write(res);
@@ -155,10 +144,8 @@ public class WebSocketServerHandshaker08 extends WebSocketServerHandshaker {
 		// Upgrade the connection and send the handshake response.
 		ChannelPipeline p = channel.getPipeline();
 		p.remove(HttpChunkAggregator.class);
-		p.replace(HttpRequestDecoder.class, "wsdecoder",
-				new WebSocket08FrameDecoder(true, this.allowExtensions));
-		p.replace(HttpResponseEncoder.class, "wsencoder",
-				new WebSocket08FrameEncoder(false));
+		p.replace(HttpRequestDecoder.class, "wsdecoder", new WebSocket08FrameDecoder(true, this.allowExtensions));
+		p.replace(HttpResponseEncoder.class, "wsencoder", new WebSocket08FrameEncoder(false));
 
 	}
 
@@ -171,8 +158,7 @@ public class WebSocketServerHandshaker08 extends WebSocketServerHandshaker {
 	 *            Web Socket frame that was received
 	 */
 	@Override
-	public void performClosingHandshake(Channel channel,
-			CloseWebSocketFrame frame) {
+	public void performClosingHandshake(Channel channel, CloseWebSocketFrame frame) {
 		ChannelFuture f = channel.write(frame);
 		f.addListener(ChannelFutureListener.CLOSE);
 	}
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketServerHandshaker13.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketServerHandshaker13.java
index 9928743e55..56fcba8f4c 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketServerHandshaker13.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketServerHandshaker13.java
@@ -38,16 +38,14 @@ import org.jboss.netty.util.CharsetUtil;
 
 /**
  * <p>
- * Performs server side opening and closing handshakes for <a
- * href="http://tools.ietf.org/html/rfc6455">RFC 6455</a>. This was originally
- * <a href="http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17"
+ * Performs server side opening and closing handshakes for <a href="http://tools.ietf.org/html/rfc6455">RFC 6455</a>.
+ * This was originally <a href="http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17"
  * >draft-ietf-hybi-thewebsocketprotocol- 17</a>
  * </p>
  */
 public class WebSocketServerHandshaker13 extends WebSocketServerHandshaker {
 
-	private static final InternalLogger logger = InternalLoggerFactory
-			.getInstance(WebSocketServerHandshaker13.class);
+	private static final InternalLogger logger = InternalLoggerFactory.getInstance(WebSocketServerHandshaker13.class);
 
 	public static final String WEBSOCKET_17_ACCEPT_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 
@@ -57,17 +55,14 @@ public class WebSocketServerHandshaker13 extends WebSocketServerHandshaker {
 	 * Constructor specifying the destination web socket location
 	 * 
 	 * @param webSocketURL
-	 *            URL for web socket communications. e.g
-	 *            "ws://myhost.com/mypath". Subsequent web socket frames will be
+	 *            URL for web socket communications. e.g "ws://myhost.com/mypath". Subsequent web socket frames will be
 	 *            sent to this URL.
 	 * @param subProtocols
 	 *            CSV of supported protocols
 	 * @param allowExtensions
-	 *            Allow extensions to be used in the reserved bits of the web
-	 *            socket frame
+	 *            Allow extensions to be used in the reserved bits of the web socket frame
 	 */
-	public WebSocketServerHandshaker13(String webSocketURL,
-			String subProtocols, boolean allowExtensions) {
+	public WebSocketServerHandshaker13(String webSocketURL, String subProtocols, boolean allowExtensions) {
 		super(webSocketURL, subProtocols);
 		this.allowExtensions = allowExtensions;
 	}
@@ -75,8 +70,8 @@ public class WebSocketServerHandshaker13 extends WebSocketServerHandshaker {
 	/**
 	 * <p>
 	 * Handle the web socket handshake for the web socket specification <a href=
-	 * "http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17">HyBi
-	 * versions 13-17</a>. Versions 13-17 share the same wire protocol.
+	 * "http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17">HyBi versions 13-17</a>. Versions 13-17
+	 * share the same wire protocol.
 	 * </p>
 	 * 
 	 * <p>
@@ -116,13 +111,10 @@ public class WebSocketServerHandshaker13 extends WebSocketServerHandshaker {
 	public void performOpeningHandshake(Channel channel, HttpRequest req) {
 
 		if (logger.isDebugEnabled()) {
-			logger.debug(String.format(
-					"Channel %s WS version 13 handshake",
-					channel.getId()));
+			logger.debug(String.format("Channel %s WS version 13 handshake", channel.getId()));
 		}
 
-		HttpResponse res = new DefaultHttpResponse(HTTP_1_1,
-				new HttpResponseStatus(101, "Switching Protocols"));
+		HttpResponse res = new DefaultHttpResponse(HTTP_1_1, new HttpResponseStatus(101, "Switching Protocols"));
 		this.setVersion(WebSocketVersion.V13);
 
 		String key = req.getHeader(Names.SEC_WEBSOCKET_KEY);
@@ -135,9 +127,7 @@ public class WebSocketServerHandshaker13 extends WebSocketServerHandshaker {
 		String accept = base64Encode(sha1);
 
 		if (logger.isDebugEnabled()) {
-			logger.debug(String.format(
-					"WS Version 13 Server Handshake key: %s. Response: %s.", key,
-					accept));
+			logger.debug(String.format("WS Version 13 Server Handshake key: %s. Response: %s.", key, accept));
 		}
 
 		res.setStatus(new HttpResponseStatus(101, "Switching Protocols"));
@@ -146,8 +136,7 @@ public class WebSocketServerHandshaker13 extends WebSocketServerHandshaker {
 		res.addHeader(Names.SEC_WEBSOCKET_ACCEPT, accept);
 		String protocol = req.getHeader(Names.SEC_WEBSOCKET_PROTOCOL);
 		if (protocol != null) {
-			res.addHeader(Names.SEC_WEBSOCKET_PROTOCOL,
-					this.selectSubProtocol(protocol));
+			res.addHeader(Names.SEC_WEBSOCKET_PROTOCOL, this.selectSubProtocol(protocol));
 		}
 
 		channel.write(res);
@@ -155,10 +144,8 @@ public class WebSocketServerHandshaker13 extends WebSocketServerHandshaker {
 		// Upgrade the connection and send the handshake response.
 		ChannelPipeline p = channel.getPipeline();
 		p.remove(HttpChunkAggregator.class);
-		p.replace(HttpRequestDecoder.class, "wsdecoder",
-				new WebSocket13FrameDecoder(true, this.allowExtensions));
-		p.replace(HttpResponseEncoder.class, "wsencoder",
-				new WebSocket13FrameEncoder(false));
+		p.replace(HttpRequestDecoder.class, "wsdecoder", new WebSocket13FrameDecoder(true, this.allowExtensions));
+		p.replace(HttpResponseEncoder.class, "wsencoder", new WebSocket13FrameEncoder(false));
 
 	}
 
@@ -171,8 +158,7 @@ public class WebSocketServerHandshaker13 extends WebSocketServerHandshaker {
 	 *            Web Socket frame that was received
 	 */
 	@Override
-	public void performClosingHandshake(Channel channel,
-			CloseWebSocketFrame frame) {
+	public void performClosingHandshake(Channel channel, CloseWebSocketFrame frame) {
 		ChannelFuture f = channel.write(frame);
 		f.addListener(ChannelFutureListener.CLOSE);
 	}
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketServerHandshakerFactory.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketServerHandshakerFactory.java
index e46cde796a..060361586a 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketServerHandshakerFactory.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketServerHandshakerFactory.java
@@ -36,17 +36,14 @@ public class WebSocketServerHandshakerFactory {
 
 	/**
 	 * Constructor specifying the destination web socket location
-	 *
+	 * 
 	 * @param webSocketURL
-	 *            URL for web socket communications. e.g
-	 *            "ws://myhost.com/mypath". Subsequent web socket frames will be
+	 *            URL for web socket communications. e.g "ws://myhost.com/mypath". Subsequent web socket frames will be
 	 *            sent to this URL.
 	 * @param subProtocols
-	 *            CSV of supported protocols. Null if sub protocols not
-	 *            supported.
+	 *            CSV of supported protocols. Null if sub protocols not supported.
 	 * @param allowExtensions
-	 *            Allow extensions to be used in the reserved bits of the web
-	 *            socket frame
+	 *            Allow extensions to be used in the reserved bits of the web socket frame
 	 */
 	public WebSocketServerHandshakerFactory(String webSocketURL, String subProtocols, boolean allowExtensions) {
 		this.webSocketURL = webSocketURL;
@@ -56,9 +53,9 @@ public class WebSocketServerHandshakerFactory {
 
 	/**
 	 * Instances a new handshaker
-	 *
-	 * @return A new WebSocketServerHandshaker for the requested web socket
-	 *         version. Null if web socket version is not supported.
+	 * 
+	 * @return A new WebSocketServerHandshaker for the requested web socket version. Null if web socket version is not
+	 *         supported.
 	 */
 	public WebSocketServerHandshaker newHandshaker(HttpRequest req) {
 
@@ -83,7 +80,7 @@ public class WebSocketServerHandshakerFactory {
 
 	/**
 	 * Return that we need cannot not support the web socket version
-	 *
+	 * 
 	 * @param channel
 	 *            Channel
 	 */
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketVersion.java b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketVersion.java
index d0d4c7e506..776ced9de6 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketVersion.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/websocketx/WebSocketVersion.java
@@ -24,30 +24,27 @@ public enum WebSocketVersion {
 	UNKNOWN,
 
 	/**
-	 * <a href=
-	 * "http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00"
+	 * <a href= "http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00"
 	 * >draft-ietf-hybi-thewebsocketprotocol- 00</a>.
 	 */
 	V00,
 
 	/**
-	 * <a href=
-	 * "http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-10"
+	 * <a href= "http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-10"
 	 * >draft-ietf-hybi-thewebsocketprotocol- 10</a>
 	 */
 	V08,
 
 	/**
-	 * <a href="http://tools.ietf.org/html/rfc6455 ">RFC 6455</a>. This was
-	 * originally <a href=
-	 * "http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17"
-	 * >draft-ietf-hybi-thewebsocketprotocol- 17</a>
+	 * <a href="http://tools.ietf.org/html/rfc6455 ">RFC 6455</a>. This was originally <a href=
+	 * "http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17" >draft-ietf-hybi-thewebsocketprotocol-
+	 * 17</a>
 	 */
 	V13;
 
 	public String toHttpHeaderValue() {
 		if (this == V00) {
-			return "0";					
+			return "0";
 		} else if (this == V08) {
 			return "8";
 		} else if (this == V13) {