From 9244292fcaeb0b688802f6e8d4c52527b5bad45f Mon Sep 17 00:00:00 2001
From: Greg Wilkins <gregw@webtide.com>
Date: Mon, 2 Apr 2012 12:09:03 +1000
Subject: [PATCH] 375692: simplified gzipfilter

---
 .../AbstractCompressedResponseWrapper.java    | 412 ------------------
 .../http/gzip/AbstractCompressedStream.java   |  22 +-
 .../http/gzip/CompressedResponseWrapper.java  | 401 ++++++++++++++++-
 .../jetty/http/gzip/CompressedStream.java     |  77 ----
 .../jetty/http/gzip/CompressionType.java      |  48 --
 .../http/gzip/DeflateResponseWrapperImpl.java |  54 ---
 .../jetty/http/gzip/DeflateStreamImpl.java    |  55 ---
 .../http/gzip/GzipResponseWrapperImpl.java    |  53 ---
 .../jetty/http/gzip/GzipStreamImpl.java       |  56 ---
 .../jetty/server/handler/GzipHandler.java     |  24 +-
 .../eclipse/jetty/servlets/GzipFilter.java    |  70 ++-
 .../jetty/servlets/IncludableGzipFilter.java  | 138 +++---
 .../servlets/GzipFilterContentLengthTest.java |  39 +-
 .../GzipFilterDefaultNoRecompressTest.java    |  61 ++-
 .../jetty/servlets/GzipFilterDefaultTest.java |  23 +-
 .../servlets/GzipWithPipeliningTest.java      |  13 +-
 .../IncludableGzipFilterMinSizeTest.java      |  13 +-
 .../servlets/IncludableGzipFilterTest.java    |  21 +-
 .../jetty/servlets/gzip/GzipTester.java       |  19 +-
 19 files changed, 618 insertions(+), 981 deletions(-)
 delete mode 100644 jetty-http/src/main/java/org/eclipse/jetty/http/gzip/AbstractCompressedResponseWrapper.java
 delete mode 100644 jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressedStream.java
 delete mode 100644 jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressionType.java
 delete mode 100644 jetty-http/src/main/java/org/eclipse/jetty/http/gzip/DeflateResponseWrapperImpl.java
 delete mode 100644 jetty-http/src/main/java/org/eclipse/jetty/http/gzip/DeflateStreamImpl.java
 delete mode 100644 jetty-http/src/main/java/org/eclipse/jetty/http/gzip/GzipResponseWrapperImpl.java
 delete mode 100644 jetty-http/src/main/java/org/eclipse/jetty/http/gzip/GzipStreamImpl.java

diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/AbstractCompressedResponseWrapper.java b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/AbstractCompressedResponseWrapper.java
deleted file mode 100644
index 95c69109e99..00000000000
--- a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/AbstractCompressedResponseWrapper.java
+++ /dev/null
@@ -1,412 +0,0 @@
-// ========================================================================
-// Copyright (c) 2009-2009 Mort Bay Consulting Pty. Ltd.
-// ------------------------------------------------------------------------
-// All rights reserved. This program and the accompanying materials
-// are made available under the terms of the Eclipse Public License v1.0
-// and Apache License v2.0 which accompanies this distribution.
-// The Eclipse Public License is available at 
-// http://www.eclipse.org/legal/epl-v10.html
-// The Apache License v2.0 is available at
-// http://www.opensource.org/licenses/apache2.0.php
-// You may elect to redistribute this code under either of these licenses. 
-// ========================================================================
-
-package org.eclipse.jetty.http.gzip;
-
-import java.io.IOException;
-import java.io.OutputStream;
-import java.io.OutputStreamWriter;
-import java.io.PrintWriter;
-import java.io.UnsupportedEncodingException;
-import java.util.Set;
-
-import javax.servlet.ServletOutputStream;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-import javax.servlet.http.HttpServletResponseWrapper;
-
-import org.eclipse.jetty.util.StringUtil;
-
-/*------------------------------------------------------------ */
-/**
- * Skeletal implementation of the CompressedResponseWrapper interface.
- * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper
- */
-public abstract class AbstractCompressedResponseWrapper extends HttpServletResponseWrapper implements CompressedResponseWrapper
-{
-    
-    public static final int DEFAULT_BUFFER_SIZE = 8192;
-    public static final int DEFAULT_MIN_COMPRESS_SIZE = 256;
-    
-    private Set<String> _mimeTypes;
-    private int _bufferSize=DEFAULT_BUFFER_SIZE;
-    private int _minCompressSize=DEFAULT_MIN_COMPRESS_SIZE;
-    private HttpServletRequest _request;
-
-    private PrintWriter _writer;
-    private CompressedStream _compressedStream;
-    private long _contentLength=-1;
-    private boolean _noCompression;
-
-    public AbstractCompressedResponseWrapper(HttpServletRequest request, HttpServletResponse response)
-    {
-        super(response);
-        _request = request;
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setMimeTypes(java.util.Set)
-     */
-    public void setMimeTypes(Set<String> mimeTypes)
-    {
-        _mimeTypes = mimeTypes;
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setBufferSize(int)
-     */
-    @Override
-    public void setBufferSize(int bufferSize)
-    {
-        _bufferSize = bufferSize;
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setMinCompressSize(int)
-     */
-    public void setMinCompressSize(int minCompressSize)
-    {
-        _minCompressSize = minCompressSize;
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setContentType(java.lang.String)
-     */
-    @Override
-    public void setContentType(String ct)
-    {
-        super.setContentType(ct);
-    
-        if (ct!=null)
-        {
-            int colon=ct.indexOf(";");
-            if (colon>0)
-                ct=ct.substring(0,colon);
-        }
-    
-        if ((_compressedStream==null || _compressedStream.getOutputStream()==null) && 
-            (_mimeTypes==null && ct!=null && ct.contains("gzip") ||
-             _mimeTypes!=null && (ct==null||!_mimeTypes.contains(StringUtil.asciiToLowerCase(ct)))))
-        {
-            noCompression();
-        }
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setStatus(int, java.lang.String)
-     */
-    @Override
-    public void setStatus(int sc, String sm)
-    {
-        super.setStatus(sc,sm);
-        if (sc<200 || sc==204 || sc==205 || sc>=300)
-            noCompression();
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setStatus(int)
-     */
-    @Override
-    public void setStatus(int sc)
-    {
-        super.setStatus(sc);
-        if (sc<200 || sc==204 || sc==205 ||sc>=300)
-            noCompression();
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setContentLength(int)
-     */
-    @Override
-    public void setContentLength(int length)
-    {
-        setContentLength((long)length);
-    }
-
-    protected void setContentLength(long length)
-    {
-        _contentLength=length;
-        if (_compressedStream!=null)
-            _compressedStream.setContentLength(length);
-        else if (_noCompression && _contentLength>=0)
-        {
-            HttpServletResponse response = (HttpServletResponse)getResponse();
-            if(_contentLength<Integer.MAX_VALUE)
-            {
-                response.setContentLength((int)_contentLength);
-            }
-            else
-            {
-                response.setHeader("Content-Length", Long.toString(_contentLength));
-            }
-        }
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#addHeader(java.lang.String, java.lang.String)
-     */
-    @Override
-    public void addHeader(String name, String value)
-    {
-        if ("content-length".equalsIgnoreCase(name))
-        {
-            _contentLength=Long.parseLong(value);
-            if (_compressedStream!=null)
-                _compressedStream.setContentLength(_contentLength);
-        }
-        else if ("content-type".equalsIgnoreCase(name))
-        {   
-            setContentType(value);
-        }
-        else if ("content-encoding".equalsIgnoreCase(name))
-        {   
-            super.addHeader(name,value);
-            if (!isCommitted())
-            {
-                noCompression();
-            }
-        }
-        else
-            super.addHeader(name,value);
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#flushBuffer()
-     */
-    @Override
-    public void flushBuffer() throws IOException
-    {
-        if (_writer!=null)
-            _writer.flush();
-        if (_compressedStream!=null)
-            _compressedStream.finish();
-        else
-            getResponse().flushBuffer();
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#reset()
-     */
-    @Override
-    public void reset()
-    {
-        super.reset();
-        if (_compressedStream!=null)
-            _compressedStream.resetBuffer();
-        _writer=null;
-        _compressedStream=null;
-        _noCompression=false;
-        _contentLength=-1;
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#resetBuffer()
-     */
-    @Override
-    public void resetBuffer()
-    {
-        super.resetBuffer();
-        if (_compressedStream!=null)
-            _compressedStream.resetBuffer();
-        _writer=null;
-        _compressedStream=null;
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#sendError(int, java.lang.String)
-     */
-    @Override
-    public void sendError(int sc, String msg) throws IOException
-    {
-        resetBuffer();
-        super.sendError(sc,msg);
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#sendError(int)
-     */
-    @Override
-    public void sendError(int sc) throws IOException
-    {
-        resetBuffer();
-        super.sendError(sc);
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#sendRedirect(java.lang.String)
-     */
-    @Override
-    public void sendRedirect(String location) throws IOException
-    {
-        resetBuffer();
-        super.sendRedirect(location);
-    }
-    
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#noCompression()
-     */
-    public void noCompression()
-    {
-        _noCompression=true;
-        if (_compressedStream!=null)
-        {
-            try
-            {
-                _compressedStream.doNotCompress();
-            }
-            catch (IOException e)
-            {
-                throw new IllegalStateException(e);
-            }
-        }
-    }
-    
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#finish()
-     */
-    public void finish() throws IOException
-    {
-        if (_writer!=null && !_compressedStream.isClosed())
-            _writer.flush();
-        if (_compressedStream!=null)
-            _compressedStream.finish();
-    }
-    
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setHeader(java.lang.String, java.lang.String)
-     */
-    @Override
-    public void setHeader(String name, String value)
-    {
-        if ("content-length".equalsIgnoreCase(name))
-        {
-            setContentLength(Long.parseLong(value));
-        }
-        else if ("content-type".equalsIgnoreCase(name))
-        {   
-            setContentType(value);
-        }
-        else if ("content-encoding".equalsIgnoreCase(name))
-        {   
-            super.setHeader(name,value);
-            if (!isCommitted())
-            {
-                noCompression();
-            }
-        }
-        else
-            super.setHeader(name,value);
-    }
-    
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#getOutputStream()
-     */
-    @Override
-    public ServletOutputStream getOutputStream() throws IOException
-    {
-        if (_compressedStream==null)
-        {
-            if (getResponse().isCommitted() || _noCompression)
-            {
-                setContentLength(_contentLength);
-                return getResponse().getOutputStream();
-            }
-            
-            _compressedStream=newCompressedStream(_request,(HttpServletResponse)getResponse(),_contentLength,_bufferSize,_minCompressSize);
-        }
-        else if (_writer!=null)
-            throw new IllegalStateException("getWriter() called");
-        
-        return (ServletOutputStream)_compressedStream;   
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#getWriter()
-     */
-    @Override
-    public PrintWriter getWriter() throws IOException
-    {
-        if (_writer==null)
-        { 
-            if (_compressedStream!=null)
-                throw new IllegalStateException("getOutputStream() called");
-            
-            if (getResponse().isCommitted() || _noCompression)
-            {
-                setContentLength(_contentLength);
-                return getResponse().getWriter();
-            }
-            
-            _compressedStream=newCompressedStream(_request,(HttpServletResponse)getResponse(),_contentLength,_bufferSize,_minCompressSize);
-            _writer=newWriter((OutputStream)_compressedStream,getCharacterEncoding());
-        }
-        return _writer;   
-    }
-    
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setIntHeader(java.lang.String, int)
-     */
-    @Override
-    public void setIntHeader(String name, int value)
-    {
-        if ("content-length".equalsIgnoreCase(name))
-        {
-            _contentLength=value;
-            if (_compressedStream!=null)
-                _compressedStream.setContentLength(_contentLength);
-        }
-        else
-            super.setIntHeader(name,value);
-    }
-    
-    /* ------------------------------------------------------------ */
-    /**
-     * Allows derived implementations to replace PrintWriter implementation.
-     *
-     * @param out the out
-     * @param encoding the encoding
-     * @return the prints the writer
-     * @throws UnsupportedEncodingException the unsupported encoding exception
-     */
-    protected PrintWriter newWriter(OutputStream out,String encoding) throws UnsupportedEncodingException
-    {
-        return encoding==null?new PrintWriter(out):new PrintWriter(new OutputStreamWriter(out,encoding));
-    }
-    
-    /* ------------------------------------------------------------ */
-    /**
-     *@return the underlying CompressedStream implementation 
-     */
-    protected abstract CompressedStream newCompressedStream(HttpServletRequest _request, HttpServletResponse response, long _contentLength2, int _bufferSize2, int _minCompressedSize2) throws IOException;
-
-}
\ No newline at end of file
diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/AbstractCompressedStream.java b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/AbstractCompressedStream.java
index 0e8e1f18c9c..f879610be29 100644
--- a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/AbstractCompressedStream.java
+++ b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/AbstractCompressedStream.java
@@ -13,6 +13,8 @@
 
 package org.eclipse.jetty.http.gzip;
 
+import java.io.Closeable;
+import java.io.Flushable;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.io.OutputStreamWriter;
@@ -32,8 +34,9 @@ import org.eclipse.jetty.util.ByteArrayOutputStream2;
  * Major work and configuration is done here. Subclasses using different kinds of compression only have to implement the abstract methods doCompress() and
  * setContentEncoding() using the desired compression and setting the appropiate Content-Encoding header string.
  */
-public abstract class AbstractCompressedStream extends ServletOutputStream implements CompressedStream
+public abstract class AbstractCompressedStream extends ServletOutputStream 
 {
+    private final String _encoding;
     protected HttpServletRequest _request;
     protected HttpServletResponse _response;
     protected OutputStream _out;
@@ -61,9 +64,10 @@ public abstract class AbstractCompressedStream extends ServletOutputStream imple
      * @throws IOException
      *             Signals that an I/O exception has occurred.
      */
-    public AbstractCompressedStream(HttpServletRequest request, HttpServletResponse response, long contentLength, int bufferSize, int minCompressSize)
+    public AbstractCompressedStream(String encoding,HttpServletRequest request, HttpServletResponse response, long contentLength, int bufferSize, int minCompressSize)
             throws IOException
     {
+        _encoding=encoding;
         _request = request;
         _response = response;
         _contentLength = contentLength;
@@ -232,7 +236,9 @@ public abstract class AbstractCompressedStream extends ServletOutputStream imple
             if (_response.isCommitted())
                 throw new IllegalStateException();
             
-            if (setContentEncoding())
+            setHeader("Content-Encoding", _encoding);
+            
+            if (_response.containsHeader("Content-Encoding"))
             {
                 _out=_compressedOutputStream=createStream();
 
@@ -325,12 +331,10 @@ public abstract class AbstractCompressedStream extends ServletOutputStream imple
         return encoding == null?new PrintWriter(out):new PrintWriter(new OutputStreamWriter(out,encoding));
     }
 
-    /**
-     * Sets the content encoding.
-     * 
-     * @return true, if successful
-     */
-    protected abstract boolean setContentEncoding();
+    protected void setHeader(String name,String value)
+    {
+        _response.setHeader(name, value);
+    }
     
     /**
      * Create the stream fitting to the underlying compression type.
diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressedResponseWrapper.java b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressedResponseWrapper.java
index 14bdc6bb612..1431f3868e2 100644
--- a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressedResponseWrapper.java
+++ b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressedResponseWrapper.java
@@ -14,45 +14,398 @@
 package org.eclipse.jetty.http.gzip;
 
 import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.UnsupportedEncodingException;
 import java.util.Set;
 
+import javax.servlet.ServletOutputStream;
+import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpServletResponseWrapper;
 
-/* ------------------------------------------------------------ */
+import org.eclipse.jetty.util.StringUtil;
+
+/*------------------------------------------------------------ */
 /**
- * A ResponseWrapper interface that adds compress functionality to a ResponseWrapper
  */
-public interface CompressedResponseWrapper extends HttpServletResponse
+public abstract class CompressedResponseWrapper extends HttpServletResponseWrapper
 {
+    
+    public static final int DEFAULT_BUFFER_SIZE = 8192;
+    public static final int DEFAULT_MIN_COMPRESS_SIZE = 256;
+    
+    private Set<String> _mimeTypes;
+    private int _bufferSize=DEFAULT_BUFFER_SIZE;
+    private int _minCompressSize=DEFAULT_MIN_COMPRESS_SIZE;
+    protected HttpServletRequest _request;
 
-    /**
-     * Sets the mime types.
-     * 
-     * @param mimeTypes
-     *            the new mime types
-     */
-    public void setMimeTypes(Set<String> mimeTypes);
+    private PrintWriter _writer;
+    private AbstractCompressedStream _compressedStream;
+    private long _contentLength=-1;
+    private boolean _noCompression;
 
-    /**
-     * Sets the min compress size.
-     * 
-     * @param minCompressSize
-     *            the new min compress size
-     */
-    public void setMinCompressSize(int minCompressSize);
+    public CompressedResponseWrapper(HttpServletRequest request, HttpServletResponse response)
+    {
+        super(response);
+        _request = request;
+    }
 
     /* ------------------------------------------------------------ */
     /**
-     * No compression.
+     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setMimeTypes(java.util.Set)
      */
-    public void noCompression();
+    public void setMimeTypes(Set<String> mimeTypes)
+    {
+        _mimeTypes = mimeTypes;
+    }
 
+    /* ------------------------------------------------------------ */
     /**
-     * Finish.
-     * 
-     * @throws IOException
-     *             Signals that an I/O exception has occurred.
+     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setBufferSize(int)
      */
-    public void finish() throws IOException;
+    @Override
+    public void setBufferSize(int bufferSize)
+    {
+        _bufferSize = bufferSize;
+    }
+
+    /* ------------------------------------------------------------ */
+    /**
+     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setMinCompressSize(int)
+     */
+    public void setMinCompressSize(int minCompressSize)
+    {
+        _minCompressSize = minCompressSize;
+    }
+
+    /* ------------------------------------------------------------ */
+    /**
+     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setContentType(java.lang.String)
+     */
+    @Override
+    public void setContentType(String ct)
+    {
+        super.setContentType(ct);
+    
+        if (ct!=null)
+        {
+            int colon=ct.indexOf(";");
+            if (colon>0)
+                ct=ct.substring(0,colon);
+        }
+    
+        if ((_compressedStream==null || _compressedStream.getOutputStream()==null) && 
+            (_mimeTypes==null && ct!=null && ct.contains("gzip") ||
+             _mimeTypes!=null && (ct==null||!_mimeTypes.contains(StringUtil.asciiToLowerCase(ct)))))
+        {
+            noCompression();
+        }
+    }
+
+    /* ------------------------------------------------------------ */
+    /**
+     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setStatus(int, java.lang.String)
+     */
+    @Override
+    public void setStatus(int sc, String sm)
+    {
+        super.setStatus(sc,sm);
+        if (sc<200 || sc==204 || sc==205 || sc>=300)
+            noCompression();
+    }
+
+    /* ------------------------------------------------------------ */
+    /**
+     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setStatus(int)
+     */
+    @Override
+    public void setStatus(int sc)
+    {
+        super.setStatus(sc);
+        if (sc<200 || sc==204 || sc==205 ||sc>=300)
+            noCompression();
+    }
+
+    /* ------------------------------------------------------------ */
+    /**
+     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setContentLength(int)
+     */
+    @Override
+    public void setContentLength(int length)
+    {
+        setContentLength((long)length);
+    }
+    
+    /* ------------------------------------------------------------ */
+    protected void setContentLength(long length)
+    {
+        _contentLength=length;
+        if (_compressedStream!=null)
+            _compressedStream.setContentLength(length);
+        else if (_noCompression && _contentLength>=0)
+        {
+            HttpServletResponse response = (HttpServletResponse)getResponse();
+            if(_contentLength<Integer.MAX_VALUE)
+            {
+                response.setContentLength((int)_contentLength);
+            }
+            else
+            {
+                response.setHeader("Content-Length", Long.toString(_contentLength));
+            }
+        }
+    }
+
+    /* ------------------------------------------------------------ */
+    /**
+     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#addHeader(java.lang.String, java.lang.String)
+     */
+    @Override
+    public void addHeader(String name, String value)
+    {
+        if ("content-length".equalsIgnoreCase(name))
+        {
+            _contentLength=Long.parseLong(value);
+            if (_compressedStream!=null)
+                _compressedStream.setContentLength(_contentLength);
+        }
+        else if ("content-type".equalsIgnoreCase(name))
+        {   
+            setContentType(value);
+        }
+        else if ("content-encoding".equalsIgnoreCase(name))
+        {   
+            super.addHeader(name,value);
+            if (!isCommitted())
+            {
+                noCompression();
+            }
+        }
+        else
+            super.addHeader(name,value);
+    }
+
+    /* ------------------------------------------------------------ */
+    /**
+     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#flushBuffer()
+     */
+    @Override
+    public void flushBuffer() throws IOException
+    {
+        if (_writer!=null)
+            _writer.flush();
+        if (_compressedStream!=null)
+            _compressedStream.finish();
+        else
+            getResponse().flushBuffer();
+    }
+
+    /* ------------------------------------------------------------ */
+    /**
+     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#reset()
+     */
+    @Override
+    public void reset()
+    {
+        super.reset();
+        if (_compressedStream!=null)
+            _compressedStream.resetBuffer();
+        _writer=null;
+        _compressedStream=null;
+        _noCompression=false;
+        _contentLength=-1;
+    }
+
+    /* ------------------------------------------------------------ */
+    /**
+     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#resetBuffer()
+     */
+    @Override
+    public void resetBuffer()
+    {
+        super.resetBuffer();
+        if (_compressedStream!=null)
+            _compressedStream.resetBuffer();
+        _writer=null;
+        _compressedStream=null;
+    }
+
+    /* ------------------------------------------------------------ */
+    /**
+     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#sendError(int, java.lang.String)
+     */
+    @Override
+    public void sendError(int sc, String msg) throws IOException
+    {
+        resetBuffer();
+        super.sendError(sc,msg);
+    }
+
+    /* ------------------------------------------------------------ */
+    /**
+     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#sendError(int)
+     */
+    @Override
+    public void sendError(int sc) throws IOException
+    {
+        resetBuffer();
+        super.sendError(sc);
+    }
+
+    /* ------------------------------------------------------------ */
+    /**
+     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#sendRedirect(java.lang.String)
+     */
+    @Override
+    public void sendRedirect(String location) throws IOException
+    {
+        resetBuffer();
+        super.sendRedirect(location);
+    }
+    
+    /* ------------------------------------------------------------ */
+    /**
+     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#noCompression()
+     */
+    public void noCompression()
+    {
+        _noCompression=true;
+        if (_compressedStream!=null)
+        {
+            try
+            {
+                _compressedStream.doNotCompress();
+            }
+            catch (IOException e)
+            {
+                throw new IllegalStateException(e);
+            }
+        }
+    }
+    
+    /* ------------------------------------------------------------ */
+    /**
+     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#finish()
+     */
+    public void finish() throws IOException
+    {
+        if (_writer!=null && !_compressedStream.isClosed())
+            _writer.flush();
+        if (_compressedStream!=null)
+            _compressedStream.finish();
+    }
+    
+    /* ------------------------------------------------------------ */
+    /**
+     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setHeader(java.lang.String, java.lang.String)
+     */
+    @Override
+    public void setHeader(String name, String value)
+    {
+        if ("content-length".equalsIgnoreCase(name))
+        {
+            setContentLength(Long.parseLong(value));
+        }
+        else if ("content-type".equalsIgnoreCase(name))
+        {   
+            setContentType(value);
+        }
+        else if ("content-encoding".equalsIgnoreCase(name))
+        {   
+            super.setHeader(name,value);
+            if (!isCommitted())
+            {
+                noCompression();
+            }
+        }
+        else
+            super.setHeader(name,value);
+    }
+    
+    /* ------------------------------------------------------------ */
+    /**
+     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#getOutputStream()
+     */
+    @Override
+    public ServletOutputStream getOutputStream() throws IOException
+    {
+        if (_compressedStream==null)
+        {
+            if (getResponse().isCommitted() || _noCompression)
+            {
+                setContentLength(_contentLength);
+                return getResponse().getOutputStream();
+            }
+            
+            _compressedStream=newCompressedStream(_request,(HttpServletResponse)getResponse(),_contentLength,_bufferSize,_minCompressSize);
+        }
+        else if (_writer!=null)
+            throw new IllegalStateException("getWriter() called");
+        
+        return (ServletOutputStream)_compressedStream;   
+    }
+
+    /* ------------------------------------------------------------ */
+    /**
+     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#getWriter()
+     */
+    @Override
+    public PrintWriter getWriter() throws IOException
+    {
+        if (_writer==null)
+        { 
+            if (_compressedStream!=null)
+                throw new IllegalStateException("getOutputStream() called");
+            
+            if (getResponse().isCommitted() || _noCompression)
+            {
+                setContentLength(_contentLength);
+                return getResponse().getWriter();
+            }
+            
+            _compressedStream=newCompressedStream(_request,(HttpServletResponse)getResponse(),_contentLength,_bufferSize,_minCompressSize);
+            _writer=newWriter((OutputStream)_compressedStream,getCharacterEncoding());
+        }
+        return _writer;   
+    }
+    
+    /* ------------------------------------------------------------ */
+    /**
+     * @see org.eclipse.jetty.http.gzip.CompressedResponseWrapper#setIntHeader(java.lang.String, int)
+     */
+    @Override
+    public void setIntHeader(String name, int value)
+    {
+        if ("content-length".equalsIgnoreCase(name))
+        {
+            _contentLength=value;
+            if (_compressedStream!=null)
+                _compressedStream.setContentLength(_contentLength);
+        }
+        else
+            super.setIntHeader(name,value);
+    }
+    
+    /* ------------------------------------------------------------ */
+    /**
+     * Allows derived implementations to replace PrintWriter implementation.
+     *
+     * @param out the out
+     * @param encoding the encoding
+     * @return the prints the writer
+     * @throws UnsupportedEncodingException the unsupported encoding exception
+     */
+    protected PrintWriter newWriter(OutputStream out,String encoding) throws UnsupportedEncodingException
+    {
+        return encoding==null?new PrintWriter(out):new PrintWriter(new OutputStreamWriter(out,encoding));
+    }
+    
+    /* ------------------------------------------------------------ */
+    /**
+     *@return the underlying CompressedStream implementation 
+     */
+    protected abstract AbstractCompressedStream newCompressedStream(HttpServletRequest _request, HttpServletResponse response, long _contentLength2, int _bufferSize2, int _minCompressedSize2) throws IOException;
 
 }
\ No newline at end of file
diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressedStream.java b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressedStream.java
deleted file mode 100644
index 751b2f05d1e..00000000000
--- a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressedStream.java
+++ /dev/null
@@ -1,77 +0,0 @@
-// ========================================================================
-// Copyright (c) 2009-2009 Mort Bay Consulting Pty. Ltd.
-// ------------------------------------------------------------------------
-// All rights reserved. This program and the accompanying materials
-// are made available under the terms of the Eclipse Public License v1.0
-// and Apache License v2.0 which accompanies this distribution.
-// The Eclipse Public License is available at 
-// http://www.eclipse.org/legal/epl-v10.html
-// The Apache License v2.0 is available at
-// http://www.opensource.org/licenses/apache2.0.php
-// You may elect to redistribute this code under either of these licenses. 
-// ========================================================================
-
-package org.eclipse.jetty.http.gzip;
-
-import java.io.Closeable;
-import java.io.Flushable;
-import java.io.IOException;
-import java.io.OutputStream;
-
-/* ------------------------------------------------------------ */
-/**
-* Interface for compressed streams
-*/
-public interface CompressedStream extends Closeable, Flushable
-{
-
-    /**
-     * Reset buffer.
-     */
-    public void resetBuffer();
-
-    /**
-     * Sets the content length.
-     * 
-     * @param length
-     *            the new content length
-     */
-    public void setContentLength(long length);
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @return true if stream is closed
-     */
-    public boolean isClosed();
-
-    /**
-     * Do compress.
-     * 
-     * @throws IOException
-     *             Signals that an I/O exception has occurred.
-     */
-    public void doCompress() throws IOException;
-
-    /**
-     * Do not compress.
-     * 
-     * @throws IOException
-     *             Signals that an I/O exception has occurred.
-     */
-    public void doNotCompress() throws IOException;
-
-    /**
-     * Finish.
-     * 
-     * @throws IOException
-     *             Signals that an I/O exception has occurred.
-     */
-    public void finish() throws IOException;
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @return the {@link OutputStream}
-     */
-    public OutputStream getOutputStream();
-
-}
\ No newline at end of file
diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressionType.java b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressionType.java
deleted file mode 100644
index 4b75c2631d3..00000000000
--- a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/CompressionType.java
+++ /dev/null
@@ -1,48 +0,0 @@
-// ========================================================================
-// Copyright (c) 2009-2009 Mort Bay Consulting Pty. Ltd.
-// ------------------------------------------------------------------------
-// All rights reserved. This program and the accompanying materials
-// are made available under the terms of the Eclipse Public License v1.0
-// and Apache License v2.0 which accompanies this distribution.
-// The Eclipse Public License is available at 
-// http://www.eclipse.org/legal/epl-v10.html
-// The Apache License v2.0 is available at
-// http://www.opensource.org/licenses/apache2.0.php
-// You may elect to redistribute this code under either of these licenses. 
-// ========================================================================
-
-package org.eclipse.jetty.http.gzip;
-
-public enum CompressionType
-{
-    GZIP("gzip"), DEFLATE("deflate"), UNSUPPORTED("unsupported");
-
-    private final String encodingHeader;
-
-    private CompressionType(String encodingHeader)
-    {
-        this.encodingHeader = encodingHeader;
-    }
-
-    public String getEncodingHeader()
-    {
-        return encodingHeader;
-    }
-
-    public static CompressionType getByEncodingHeader(String encodingHeader)
-    {
-        // prefer gzip over deflate
-        if (encodingHeader.toLowerCase().contains(CompressionType.GZIP.encodingHeader))
-        {
-            return CompressionType.GZIP;
-        }
-        else if (encodingHeader.toLowerCase().contains(CompressionType.DEFLATE.encodingHeader))
-        {
-            return CompressionType.DEFLATE;
-        }
-        else
-        {
-            return CompressionType.UNSUPPORTED;
-        }
-    }
-}
\ No newline at end of file
diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/DeflateResponseWrapperImpl.java b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/DeflateResponseWrapperImpl.java
deleted file mode 100644
index 9cf5fe02673..00000000000
--- a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/DeflateResponseWrapperImpl.java
+++ /dev/null
@@ -1,54 +0,0 @@
-// ========================================================================
-// Copyright (c) Webtide LLC
-// ------------------------------------------------------------------------
-// All rights reserved. This program and the accompanying materials
-// are made available under the terms of the Eclipse Public License v1.0
-// and Apache License v2.0 which accompanies this distribution.
-// The Eclipse Public License is available at 
-// http://www.eclipse.org/legal/epl-v10.html
-// The Apache License v2.0 is available at
-// http://www.opensource.org/licenses/apache2.0.php
-// You may elect to redistribute this code under either of these licenses. 
-// ========================================================================
-
-
-package org.eclipse.jetty.http.gzip;
-
-import java.io.IOException;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
-/* ------------------------------------------------------------ */
-/**
- */
-public class DeflateResponseWrapperImpl extends AbstractCompressedResponseWrapper
-{
-    /**
-     * Instantiates a new deflate response wrapper.
-     *
-     * @param request the request
-     * @param response the response
-     */
-    public DeflateResponseWrapperImpl(HttpServletRequest request, HttpServletResponse response)
-    {
-        super(request,response);
-    }
-
-    
-    /* ------------------------------------------------------------ */
-    /**
-     * @param request the request
-     * @param response the response
-     * @param contentLength the content length
-     * @param bufferSize the buffer size
-     * @param minCompressSize the min compress size
-     * @return the deflate stream
-     * @throws IOException Signals that an I/O exception has occurred.
-     */
-    @Override
-    protected CompressedStream newCompressedStream(HttpServletRequest request,HttpServletResponse response,long contentLength,int bufferSize, int minCompressSize) throws IOException
-    {
-        return new DeflateStreamImpl(request,response,contentLength,bufferSize,minCompressSize);
-    }
-}
-
diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/DeflateStreamImpl.java b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/DeflateStreamImpl.java
deleted file mode 100644
index 16e3d82750d..00000000000
--- a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/DeflateStreamImpl.java
+++ /dev/null
@@ -1,55 +0,0 @@
-// ========================================================================
-// Copyright (c) Webtide LLC
-// ------------------------------------------------------------------------
-// All rights reserved. This program and the accompanying materials
-// are made available under the terms of the Eclipse Public License v1.0
-// and Apache License v2.0 which accompanies this distribution.
-// The Eclipse Public License is available at 
-// http://www.eclipse.org/legal/epl-v10.html
-// The Apache License v2.0 is available at
-// http://www.opensource.org/licenses/apache2.0.php
-// You may elect to redistribute this code under either of these licenses. 
-// ========================================================================
-
-package org.eclipse.jetty.http.gzip;
-
-import java.io.IOException;
-import java.util.zip.DeflaterOutputStream;
-
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
-
-/* ------------------------------------------------------------ */
-/**
- * Compressed Stream implementation using deflate to compress
- */
-public class DeflateStreamImpl extends AbstractCompressedStream implements CompressedStream
-{
-    public DeflateStreamImpl(HttpServletRequest request, HttpServletResponse response, long contentLength, int bufferSize, int minGzipSize) throws IOException
-    {
-        super(request,response,contentLength,bufferSize,minGzipSize);
-    }
-
-    /**
-     * Sets the Content-Encoding header to deflate.
-     *
-     * @return true, if successful
-     */
-    @Override
-    protected boolean setContentEncoding()
-    {
-        _response.setHeader("Content-Encoding", CompressionType.DEFLATE.getEncodingHeader());
-        return _response.containsHeader("Content-Encoding");
-    }
-
-    /**
-     * @return a new DeflaterOutputStream backed by _response.getOutputStream()
-     */
-    @Override
-    protected DeflaterOutputStream createStream() throws IOException
-    {
-        return new DeflaterOutputStream(_response.getOutputStream());
-    }
-}
-
diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/GzipResponseWrapperImpl.java b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/GzipResponseWrapperImpl.java
deleted file mode 100644
index f434ad27c3f..00000000000
--- a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/GzipResponseWrapperImpl.java
+++ /dev/null
@@ -1,53 +0,0 @@
-// ========================================================================
-// Copyright (c) Webtide LLC
-// ------------------------------------------------------------------------
-// All rights reserved. This program and the accompanying materials
-// are made available under the terms of the Eclipse Public License v1.0
-// and Apache License v2.0 which accompanies this distribution.
-// The Eclipse Public License is available at 
-// http://www.eclipse.org/legal/epl-v10.html
-// The Apache License v2.0 is available at
-// http://www.opensource.org/licenses/apache2.0.php
-// You may elect to redistribute this code under either of these licenses. 
-// ========================================================================
-
-package org.eclipse.jetty.http.gzip;
-
-import java.io.IOException;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
-/* ------------------------------------------------------------ */
-/**
- */
-public class GzipResponseWrapperImpl extends AbstractCompressedResponseWrapper
-{
-    /**
-     * Instantiates a new gzip response wrapper.
-     *
-     * @param request the request
-     * @param response the response
-     */
-    public GzipResponseWrapperImpl(HttpServletRequest request, HttpServletResponse response)
-    {
-        super(request,response);
-    }
-
-    
-    /* ------------------------------------------------------------ */
-    /**
-     * @param request the request
-     * @param response the response
-     * @param contentLength the content length
-     * @param bufferSize the buffer size
-     * @param minCompressSize the min gzip size
-     * @return the gzip stream
-     * @throws IOException Signals that an I/O exception has occurred.
-     */
-    @Override
-    protected CompressedStream newCompressedStream(HttpServletRequest request,HttpServletResponse response,long contentLength,int bufferSize, int minCompressSize) throws IOException
-    {
-        return new GzipStreamImpl(request,response,contentLength,bufferSize,minCompressSize);
-    }
-}
-
diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/GzipStreamImpl.java b/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/GzipStreamImpl.java
deleted file mode 100644
index 218aebca38d..00000000000
--- a/jetty-http/src/main/java/org/eclipse/jetty/http/gzip/GzipStreamImpl.java
+++ /dev/null
@@ -1,56 +0,0 @@
-// ========================================================================
-// Copyright (c) Webtide LLC
-// ------------------------------------------------------------------------
-// All rights reserved. This program and the accompanying materials
-// are made available under the terms of the Eclipse Public License v1.0
-// and Apache License v2.0 which accompanies this distribution.
-// The Eclipse Public License is available at 
-// http://www.eclipse.org/legal/epl-v10.html
-// The Apache License v2.0 is available at
-// http://www.opensource.org/licenses/apache2.0.php
-// You may elect to redistribute this code under either of these licenses. 
-// ========================================================================
-
-package org.eclipse.jetty.http.gzip;
-
-import java.io.IOException;
-import java.util.zip.DeflaterOutputStream;
-import java.util.zip.GZIPOutputStream;
-
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
-
-/* ------------------------------------------------------------ */
-/**
- * Compressed Stream implementation using gzip to compress
- */
-public class GzipStreamImpl extends AbstractCompressedStream implements CompressedStream
-{
-    public GzipStreamImpl(HttpServletRequest request, HttpServletResponse response, long contentLength, int bufferSize, int minGzipSize) throws IOException
-    {
-        super(request,response,contentLength,bufferSize,minGzipSize);
-    }
-
-    /**
-     * Sets the Content-Encoding header to gzip.
-     *
-     * @return true, if successful
-     */
-    @Override
-    protected boolean setContentEncoding()
-    {
-        _response.setHeader("Content-Encoding", CompressionType.GZIP.getEncodingHeader());
-        return _response.containsHeader("Content-Encoding");
-    }
-    
-    /**
-     * @return a new GZIPOutputStream backed by _response.getOutputStream()
-     */
-    @Override
-    protected DeflaterOutputStream createStream() throws IOException
-    {
-        return new GZIPOutputStream(_response.getOutputStream(),_bufferSize);
-    }
-}
-
diff --git a/jetty-server/src/main/java/org/eclipse/jetty/server/handler/GzipHandler.java b/jetty-server/src/main/java/org/eclipse/jetty/server/handler/GzipHandler.java
index 83bd42e152b..72af6011c0e 100644
--- a/jetty-server/src/main/java/org/eclipse/jetty/server/handler/GzipHandler.java
+++ b/jetty-server/src/main/java/org/eclipse/jetty/server/handler/GzipHandler.java
@@ -21,6 +21,8 @@ import java.io.UnsupportedEncodingException;
 import java.util.HashSet;
 import java.util.Set;
 import java.util.StringTokenizer;
+import java.util.zip.DeflaterOutputStream;
+import java.util.zip.GZIPOutputStream;
 
 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServletRequest;
@@ -30,7 +32,8 @@ import org.eclipse.jetty.continuation.Continuation;
 import org.eclipse.jetty.continuation.ContinuationListener;
 import org.eclipse.jetty.continuation.ContinuationSupport;
 import org.eclipse.jetty.http.HttpMethods;
-import org.eclipse.jetty.http.gzip.GzipResponseWrapperImpl;
+import org.eclipse.jetty.http.gzip.CompressedResponseWrapper;
+import org.eclipse.jetty.http.gzip.AbstractCompressedStream;
 import org.eclipse.jetty.server.Request;
 import org.eclipse.jetty.util.log.Log;
 import org.eclipse.jetty.util.log.Logger;
@@ -222,7 +225,7 @@ public class GzipHandler extends HandlerWrapper
                     }
                 }
 
-                final GzipResponseWrapperImpl wrappedResponse = newGzipResponseWrapper(request,response);
+                final CompressedResponseWrapper wrappedResponse = newGzipResponseWrapper(request,response);
                 
                 boolean exceptional=true;
                 try
@@ -276,9 +279,9 @@ public class GzipHandler extends HandlerWrapper
      * @param response the response
      * @return the gzip response wrapper
      */
-    protected GzipResponseWrapperImpl newGzipResponseWrapper(HttpServletRequest request, HttpServletResponse response)
+    protected CompressedResponseWrapper newGzipResponseWrapper(HttpServletRequest request, HttpServletResponse response)
     {
-        return new GzipResponseWrapperImpl(request, response)
+        return new CompressedResponseWrapper(request,response)
         {
             {
                 super.setMimeTypes(GzipHandler.this._mimeTypes);
@@ -286,6 +289,19 @@ public class GzipHandler extends HandlerWrapper
                 super.setMinCompressSize(GzipHandler.this._minGzipSize);
             }
             
+            @Override
+            protected AbstractCompressedStream newCompressedStream(HttpServletRequest request,HttpServletResponse response,long contentLength,int bufferSize, int minCompressSize) throws IOException
+            {
+                return new AbstractCompressedStream("gzip",request,response,contentLength,bufferSize,minCompressSize)
+                {
+                    @Override
+                    protected DeflaterOutputStream createStream() throws IOException
+                    {
+                        return new GZIPOutputStream(_response.getOutputStream(),_bufferSize);
+                    }
+                };
+            }
+            
             @Override
             protected PrintWriter newWriter(OutputStream out,String encoding) throws UnsupportedEncodingException
             {
diff --git a/jetty-servlets/src/main/java/org/eclipse/jetty/servlets/GzipFilter.java b/jetty-servlets/src/main/java/org/eclipse/jetty/servlets/GzipFilter.java
index 266b71887bc..40564cae0e8 100644
--- a/jetty-servlets/src/main/java/org/eclipse/jetty/servlets/GzipFilter.java
+++ b/jetty-servlets/src/main/java/org/eclipse/jetty/servlets/GzipFilter.java
@@ -17,6 +17,8 @@ import java.util.HashSet;
 import java.util.Set;
 import java.util.StringTokenizer;
 import java.util.regex.Pattern;
+import java.util.zip.DeflaterOutputStream;
+import java.util.zip.GZIPOutputStream;
 
 import javax.servlet.FilterChain;
 import javax.servlet.FilterConfig;
@@ -31,9 +33,7 @@ import org.eclipse.jetty.continuation.ContinuationListener;
 import org.eclipse.jetty.continuation.ContinuationSupport;
 import org.eclipse.jetty.http.HttpMethods;
 import org.eclipse.jetty.http.gzip.CompressedResponseWrapper;
-import org.eclipse.jetty.http.gzip.CompressionType;
-import org.eclipse.jetty.http.gzip.DeflateResponseWrapperImpl;
-import org.eclipse.jetty.http.gzip.GzipResponseWrapperImpl;
+import org.eclipse.jetty.http.gzip.AbstractCompressedStream;
 import org.eclipse.jetty.util.log.Log;
 import org.eclipse.jetty.util.log.Logger;
 
@@ -67,6 +67,8 @@ import org.eclipse.jetty.util.log.Logger;
 public class GzipFilter extends UserAgentFilter
 {
     private static final Logger LOG = Log.getLogger(GzipFilter.class);
+    public final static String GZIP="gzip";
+    public final static String DEFLATE="deflate";
 
     protected Set<String> _mimeTypes;
     protected int _bufferSize=8192;
@@ -147,7 +149,22 @@ public class GzipFilter extends UserAgentFilter
     public void destroy()
     {
     }
-
+    
+    /* ------------------------------------------------------------ */
+    public String selectCompression(String encodingHeader)
+    {
+        // TODO, this could be a little more robust.
+        // prefer gzip over deflate
+        if (encodingHeader!=null)
+        {
+            if (encodingHeader.toLowerCase().contains(GZIP))
+                return GZIP;
+            if (encodingHeader.toLowerCase().contains(DEFLATE))
+                return DEFLATE;
+        }
+        return null;
+    }
+    
     /* ------------------------------------------------------------ */
     /**
      * @see org.eclipse.jetty.servlets.UserAgentFilter#doFilter(javax.servlet.ServletRequest, javax.servlet.ServletResponse, javax.servlet.FilterChain)
@@ -160,9 +177,8 @@ public class GzipFilter extends UserAgentFilter
         HttpServletResponse response=(HttpServletResponse)res;
 
         String ae = request.getHeader("accept-encoding");
-        CompressionType compressionType = CompressionType.getByEncodingHeader(ae);
-        if (ae != null && !compressionType.equals(CompressionType.UNSUPPORTED) && !response.containsHeader("Content-Encoding")
-                && !HttpMethods.HEAD.equalsIgnoreCase(request.getMethod()))
+        String compressionType = selectCompression(request.getHeader("accept-encoding"));
+        if (compressionType!=null && !response.containsHeader("Content-Encoding") && !HttpMethods.HEAD.equalsIgnoreCase(request.getMethod()))
         {
             String ua = getUserAgent(request);
             if (isExcludedAgent(ua))
@@ -207,16 +223,44 @@ public class GzipFilter extends UserAgentFilter
         }
     }
 
-    protected CompressedResponseWrapper createWrappedResponse(HttpServletRequest request, HttpServletResponse response, CompressionType compressionType)
+    protected CompressedResponseWrapper createWrappedResponse(HttpServletRequest request, HttpServletResponse response, final String compressionType)
     {
         CompressedResponseWrapper wrappedResponse = null;
-        if (compressionType.equals(CompressionType.GZIP))
+        if (compressionType.equals(GZIP))
         {
-            wrappedResponse = new GzipResponseWrapperImpl(request,response);
+            wrappedResponse = new CompressedResponseWrapper(request,response)
+            {
+                @Override
+                protected AbstractCompressedStream newCompressedStream(HttpServletRequest request,HttpServletResponse response,long contentLength,int bufferSize, int minCompressSize) throws IOException
+                {
+                    return new AbstractCompressedStream(compressionType,request,response,contentLength,bufferSize,minCompressSize)
+                    {
+                        @Override
+                        protected DeflaterOutputStream createStream() throws IOException
+                        {
+                            return new GZIPOutputStream(_response.getOutputStream(),_bufferSize);
+                        }
+                    };
+                }
+            };
         }
-        else if (compressionType.equals(CompressionType.DEFLATE))
+        else if (compressionType.equals(DEFLATE))
         {
-            wrappedResponse = new DeflateResponseWrapperImpl(request,response);
+            wrappedResponse = new CompressedResponseWrapper(request,response)
+            {
+                @Override
+                protected AbstractCompressedStream newCompressedStream(HttpServletRequest request,HttpServletResponse response,long contentLength,int bufferSize, int minCompressSize) throws IOException
+                {
+                    return new AbstractCompressedStream(compressionType,request,response,contentLength,bufferSize,minCompressSize)
+                    {
+                        @Override
+                        protected DeflaterOutputStream createStream() throws IOException
+                        {
+                            return new DeflaterOutputStream(_response.getOutputStream());
+                        }
+                    };
+                }
+            };
         }
         else
         {
@@ -226,7 +270,7 @@ public class GzipFilter extends UserAgentFilter
         return wrappedResponse;
     }
 
-    private void configureWrappedResponse(CompressedResponseWrapper wrappedResponse)
+    protected void configureWrappedResponse(CompressedResponseWrapper wrappedResponse)
     {
         wrappedResponse.setMimeTypes(_mimeTypes);
         wrappedResponse.setBufferSize(_bufferSize);
diff --git a/jetty-servlets/src/main/java/org/eclipse/jetty/servlets/IncludableGzipFilter.java b/jetty-servlets/src/main/java/org/eclipse/jetty/servlets/IncludableGzipFilter.java
index a325dee3a99..972393e1644 100644
--- a/jetty-servlets/src/main/java/org/eclipse/jetty/servlets/IncludableGzipFilter.java
+++ b/jetty-servlets/src/main/java/org/eclipse/jetty/servlets/IncludableGzipFilter.java
@@ -18,6 +18,8 @@ import java.io.OutputStream;
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 import java.io.UnsupportedEncodingException;
+import java.util.zip.DeflaterOutputStream;
+import java.util.zip.GZIPOutputStream;
 
 import javax.servlet.FilterConfig;
 import javax.servlet.ServletException;
@@ -25,11 +27,7 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
 import org.eclipse.jetty.http.gzip.CompressedResponseWrapper;
-import org.eclipse.jetty.http.gzip.CompressedStream;
-import org.eclipse.jetty.http.gzip.CompressionType;
-import org.eclipse.jetty.http.gzip.DeflateStreamImpl;
-import org.eclipse.jetty.http.gzip.GzipResponseWrapperImpl;
-import org.eclipse.jetty.http.gzip.GzipStreamImpl;
+import org.eclipse.jetty.http.gzip.AbstractCompressedStream;
 import org.eclipse.jetty.io.UncheckedPrintWriter;
 
 /* ------------------------------------------------------------ */
@@ -58,43 +56,75 @@ public class IncludableGzipFilter extends GzipFilter
             _uncheckedPrintWriter=Boolean.valueOf(tmp).booleanValue();
     }
 
+    /* ------------------------------------------------------------ */
+    /**
+     * @see org.eclipse.jetty.servlets.GzipFilter#createWrappedResponse(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.String)
+     */
     @Override
-    protected CompressedResponseWrapper createWrappedResponse(HttpServletRequest request, HttpServletResponse response, CompressionType compressionType)
+    protected CompressedResponseWrapper createWrappedResponse(HttpServletRequest request, HttpServletResponse response, final String compressionType)
     {
-        return new IncludableResponseWrapper(request,response);
+        CompressedResponseWrapper wrappedResponse = null;
+        if (compressionType.equals(GZIP))
+        {
+            wrappedResponse = new IncludableResponseWrapper(request,response)
+            {
+                @Override
+                protected AbstractCompressedStream newCompressedStream(HttpServletRequest request,HttpServletResponse response,long contentLength,int bufferSize, int minCompressSize) throws IOException
+                {
+                    return new AbstractCompressedStream(compressionType,request,response,contentLength,bufferSize,minCompressSize)
+                    {
+                        @Override
+                        protected DeflaterOutputStream createStream() throws IOException
+                        {
+                            return new GZIPOutputStream(_response.getOutputStream(),_bufferSize);
+                        }
+                    };
+                }
+            };
+        }
+        else if (compressionType.equals(DEFLATE))
+        {
+            wrappedResponse = new IncludableResponseWrapper(request,response)
+            {
+                @Override
+                protected AbstractCompressedStream newCompressedStream(HttpServletRequest request,HttpServletResponse response,long contentLength,int bufferSize, int minCompressSize) throws IOException
+                {
+                    return new AbstractCompressedStream(compressionType,request,response,contentLength,bufferSize,minCompressSize)
+                    {
+                        @Override
+                        protected DeflaterOutputStream createStream() throws IOException
+                        {
+                            return new DeflaterOutputStream(_response.getOutputStream());
+                        }
+                    };
+                }
+            };
+        }
+        else
+        {
+            throw new IllegalStateException(compressionType + " not supported");
+        }
+        configureWrappedResponse(wrappedResponse);
+        return wrappedResponse;
     }
-
-    public class IncludableResponseWrapper extends GzipResponseWrapperImpl
+    
+    
+    // Extend CompressedResponseWrapper to be able to set headers during include and to create unchecked printwriters
+    private abstract class IncludableResponseWrapper extends CompressedResponseWrapper
     {
         public IncludableResponseWrapper(HttpServletRequest request, HttpServletResponse response)
         {
             super(request,response);
-
-            super.setMimeTypes(IncludableGzipFilter.this._mimeTypes);
-            super.setBufferSize(IncludableGzipFilter.this._bufferSize);
-            super.setMinCompressSize(IncludableGzipFilter.this._minGzipSize);
         }
 
         @Override
-        protected CompressedStream newCompressedStream(HttpServletRequest request, HttpServletResponse response, long contentLength, int bufferSize,
-                int minGzipSize) throws IOException
+        public void setHeader(String name,String value)
         {
-            String encodingHeader = request.getHeader("accept-encoding");
-            CompressionType compressionType = CompressionType.getByEncodingHeader(encodingHeader);
-            if (compressionType.equals(CompressionType.GZIP))
-            {
-                return new IncludableGzipStream(request,response,contentLength,bufferSize,minGzipSize);
-            }
-            else if (compressionType.equals(CompressionType.DEFLATE))
-            {
-                return new IncludableDeflateStream(request,response,contentLength,bufferSize,minGzipSize);
-            }
-            else
-            {
-                throw new IllegalStateException(compressionType.name() + " not supported.");
-            }
+            super.setHeader(name,value);
+            HttpServletResponse response = (HttpServletResponse)getResponse();
+            if (!response.containsHeader(name))
+                response.setHeader("org.eclipse.jetty.server.include."+name,value);;    
         }
-
         @Override
         protected PrintWriter newWriter(OutputStream out, String encoding) throws UnsupportedEncodingException
         {
@@ -104,52 +134,4 @@ public class IncludableGzipFilter extends GzipFilter
         }
     }
 
-    public class IncludableGzipStream extends GzipStreamImpl
-    {
-        public IncludableGzipStream(HttpServletRequest request, HttpServletResponse response, long contentLength, int bufferSize, int minGzipSize)
-                throws IOException
-        {
-            super(request,response,contentLength,bufferSize,minGzipSize);
-        }
-
-        @Override
-        protected boolean setContentEncoding()
-        {
-            if (_request.getAttribute("javax.servlet.include.request_uri") != null)
-            {
-                _response.setHeader("org.eclipse.jetty.server.include.Content-Encoding","gzip");
-            }
-            else
-            {
-                _response.setHeader("Content-Encoding","gzip");
-            }
-
-            return _response.containsHeader("Content-Encoding");
-        }
-    }
-
-    public class IncludableDeflateStream extends DeflateStreamImpl
-    {
-        public IncludableDeflateStream(HttpServletRequest request, HttpServletResponse response, long contentLength, int bufferSize, int minGzipSize)
-                throws IOException
-        {
-            super(request,response,contentLength,bufferSize,minGzipSize);
-        }
-
-        @Override
-        protected boolean setContentEncoding()
-        {
-            if (_request.getAttribute("javax.servlet.include.request_uri") != null)
-            {
-                _response.setHeader("org.eclipse.jetty.server.include.Content-Encoding","deflate");
-            }
-            else
-            {
-                _response.setHeader("Content-Encoding","deflate");
-            }
-
-            return _response.containsHeader("Content-Encoding");
-        }
-    }
-
 }
diff --git a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterContentLengthTest.java b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterContentLengthTest.java
index b636583c716..c752591bc25 100644
--- a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterContentLengthTest.java
+++ b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterContentLengthTest.java
@@ -6,8 +6,7 @@ import java.util.List;
 import javax.servlet.Servlet;
 
 import org.eclipse.jetty.http.HttpStatus;
-import org.eclipse.jetty.http.gzip.CompressionType;
-import org.eclipse.jetty.http.gzip.GzipResponseWrapperImpl;
+import org.eclipse.jetty.http.gzip.CompressedResponseWrapper;
 import org.eclipse.jetty.servlet.FilterHolder;
 import org.eclipse.jetty.servlets.gzip.GzipTester;
 import org.eclipse.jetty.servlets.gzip.TestServletLengthStreamTypeWrite;
@@ -49,29 +48,29 @@ public class GzipFilterContentLengthTest
     {
         return Arrays.asList(new Object[][]
         {
-        { TestServletLengthStreamTypeWrite.class, CompressionType.GZIP },
-        { TestServletLengthTypeStreamWrite.class, CompressionType.GZIP },
-        { TestServletStreamLengthTypeWrite.class, CompressionType.GZIP },
-        { TestServletStreamTypeLengthWrite.class, CompressionType.GZIP },
-        { TestServletTypeLengthStreamWrite.class, CompressionType.GZIP },
-        { TestServletTypeStreamLengthWrite.class, CompressionType.GZIP }, 
-        { TestServletLengthStreamTypeWrite.class, CompressionType.DEFLATE },
-        { TestServletLengthTypeStreamWrite.class, CompressionType.DEFLATE },
-        { TestServletStreamLengthTypeWrite.class, CompressionType.DEFLATE },
-        { TestServletStreamTypeLengthWrite.class, CompressionType.DEFLATE },
-        { TestServletTypeLengthStreamWrite.class, CompressionType.DEFLATE },
-        { TestServletTypeStreamLengthWrite.class, CompressionType.DEFLATE } 
+        { TestServletLengthStreamTypeWrite.class, GzipFilter.GZIP },
+        { TestServletLengthTypeStreamWrite.class, GzipFilter.GZIP },
+        { TestServletStreamLengthTypeWrite.class, GzipFilter.GZIP },
+        { TestServletStreamTypeLengthWrite.class, GzipFilter.GZIP },
+        { TestServletTypeLengthStreamWrite.class, GzipFilter.GZIP },
+        { TestServletTypeStreamLengthWrite.class, GzipFilter.GZIP }, 
+        { TestServletLengthStreamTypeWrite.class, GzipFilter.DEFLATE },
+        { TestServletLengthTypeStreamWrite.class, GzipFilter.DEFLATE },
+        { TestServletStreamLengthTypeWrite.class, GzipFilter.DEFLATE },
+        { TestServletStreamTypeLengthWrite.class, GzipFilter.DEFLATE },
+        { TestServletTypeLengthStreamWrite.class, GzipFilter.DEFLATE },
+        { TestServletTypeStreamLengthWrite.class, GzipFilter.DEFLATE } 
         });
     }
 
-    private static final int LARGE = GzipResponseWrapperImpl.DEFAULT_BUFFER_SIZE * 8;
-    private static final int MEDIUM = GzipResponseWrapperImpl.DEFAULT_BUFFER_SIZE;
-    private static final int SMALL = GzipResponseWrapperImpl.DEFAULT_BUFFER_SIZE / 4;
-    private static final int TINY = GzipResponseWrapperImpl.DEFAULT_MIN_COMPRESS_SIZE/ 2;
+    private static final int LARGE = CompressedResponseWrapper.DEFAULT_BUFFER_SIZE * 8;
+    private static final int MEDIUM = CompressedResponseWrapper.DEFAULT_BUFFER_SIZE;
+    private static final int SMALL = CompressedResponseWrapper.DEFAULT_BUFFER_SIZE / 4;
+    private static final int TINY = CompressedResponseWrapper.DEFAULT_MIN_COMPRESS_SIZE/ 2;
     
-    private CompressionType compressionType;
+    private String compressionType;
 
-    public GzipFilterContentLengthTest(Class<? extends Servlet> testServlet, CompressionType compressionType)
+    public GzipFilterContentLengthTest(Class<? extends Servlet> testServlet, String compressionType)
     {
         this.testServlet = testServlet;
         this.compressionType = compressionType;
diff --git a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterDefaultNoRecompressTest.java b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterDefaultNoRecompressTest.java
index 996e26a0547..a890b96b628 100644
--- a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterDefaultNoRecompressTest.java
+++ b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterDefaultNoRecompressTest.java
@@ -5,7 +5,6 @@ import java.io.IOException;
 import java.util.Arrays;
 import java.util.List;
 
-import org.eclipse.jetty.http.gzip.CompressionType;
 import org.eclipse.jetty.servlet.DefaultServlet;
 import org.eclipse.jetty.servlet.FilterHolder;
 import org.eclipse.jetty.servlets.gzip.GzipTester;
@@ -32,41 +31,41 @@ public class GzipFilterDefaultNoRecompressTest
         return Arrays.asList(new Object[][]
         {
                 // Some already compressed files
-                { "test_quotes.gz", "application/gzip", CompressionType.GZIP },
-                { "test_quotes.bz2", "application/bzip2", CompressionType.GZIP },
-                { "test_quotes.zip", "application/zip", CompressionType.GZIP },
-                { "test_quotes.rar", "application/octet-stream", CompressionType.GZIP },
+                { "test_quotes.gz", "application/gzip", GzipFilter.GZIP },
+                { "test_quotes.bz2", "application/bzip2", GzipFilter.GZIP },
+                { "test_quotes.zip", "application/zip", GzipFilter.GZIP },
+                { "test_quotes.rar", "application/octet-stream", GzipFilter.GZIP },
                 // Some images (common first)
-                { "jetty_logo.png", "image/png", CompressionType.GZIP },
-                { "jetty_logo.gif", "image/gif", CompressionType.GZIP },
-                { "jetty_logo.jpeg", "image/jpeg", CompressionType.GZIP },
-                { "jetty_logo.jpg", "image/jpeg", CompressionType.GZIP },
+                { "jetty_logo.png", "image/png", GzipFilter.GZIP },
+                { "jetty_logo.gif", "image/gif", GzipFilter.GZIP },
+                { "jetty_logo.jpeg", "image/jpeg", GzipFilter.GZIP },
+                { "jetty_logo.jpg", "image/jpeg", GzipFilter.GZIP },
                 // Lesser encountered images (usually found being requested from non-browser clients)
-                { "jetty_logo.bmp", "image/bmp", CompressionType.GZIP },
-                { "jetty_logo.tga", "application/tga", CompressionType.GZIP },
-                { "jetty_logo.tif", "image/tiff", CompressionType.GZIP },
-                { "jetty_logo.tiff", "image/tiff", CompressionType.GZIP },
-                { "jetty_logo.xcf", "image/xcf", CompressionType.GZIP },
-                { "jetty_logo.jp2", "image/jpeg2000", CompressionType.GZIP },
+                { "jetty_logo.bmp", "image/bmp", GzipFilter.GZIP },
+                { "jetty_logo.tga", "application/tga", GzipFilter.GZIP },
+                { "jetty_logo.tif", "image/tiff", GzipFilter.GZIP },
+                { "jetty_logo.tiff", "image/tiff", GzipFilter.GZIP },
+                { "jetty_logo.xcf", "image/xcf", GzipFilter.GZIP },
+                { "jetty_logo.jp2", "image/jpeg2000", GzipFilter.GZIP },
 
                 // Same tests again for deflate
                 // Some already compressed files
-                { "test_quotes.gz", "application/gzip", CompressionType.DEFLATE },
-                { "test_quotes.bz2", "application/bzip2", CompressionType.DEFLATE },
-                { "test_quotes.zip", "application/zip", CompressionType.DEFLATE },
-                { "test_quotes.rar", "application/octet-stream", CompressionType.DEFLATE },
+                { "test_quotes.gz", "application/gzip", GzipFilter.DEFLATE },
+                { "test_quotes.bz2", "application/bzip2", GzipFilter.DEFLATE },
+                { "test_quotes.zip", "application/zip", GzipFilter.DEFLATE },
+                { "test_quotes.rar", "application/octet-stream", GzipFilter.DEFLATE },
                 // Some images (common first)
-                { "jetty_logo.png", "image/png", CompressionType.DEFLATE },
-                { "jetty_logo.gif", "image/gif", CompressionType.DEFLATE },
-                { "jetty_logo.jpeg", "image/jpeg", CompressionType.DEFLATE },
-                { "jetty_logo.jpg", "image/jpeg", CompressionType.DEFLATE },
+                { "jetty_logo.png", "image/png", GzipFilter.DEFLATE },
+                { "jetty_logo.gif", "image/gif", GzipFilter.DEFLATE },
+                { "jetty_logo.jpeg", "image/jpeg", GzipFilter.DEFLATE },
+                { "jetty_logo.jpg", "image/jpeg", GzipFilter.DEFLATE },
                 // Lesser encountered images (usually found being requested from non-browser clients)
-                { "jetty_logo.bmp", "image/bmp", CompressionType.DEFLATE },
-                { "jetty_logo.tga", "application/tga", CompressionType.DEFLATE },
-                { "jetty_logo.tif", "image/tiff", CompressionType.DEFLATE },
-                { "jetty_logo.tiff", "image/tiff", CompressionType.DEFLATE },
-                { "jetty_logo.xcf", "image/xcf", CompressionType.DEFLATE },
-                { "jetty_logo.jp2", "image/jpeg2000", CompressionType.DEFLATE } });
+                { "jetty_logo.bmp", "image/bmp", GzipFilter.DEFLATE },
+                { "jetty_logo.tga", "application/tga", GzipFilter.DEFLATE },
+                { "jetty_logo.tif", "image/tiff", GzipFilter.DEFLATE },
+                { "jetty_logo.tiff", "image/tiff", GzipFilter.DEFLATE },
+                { "jetty_logo.xcf", "image/xcf", GzipFilter.DEFLATE },
+                { "jetty_logo.jp2", "image/jpeg2000", GzipFilter.DEFLATE } });
     }
 
     @Rule
@@ -74,9 +73,9 @@ public class GzipFilterDefaultNoRecompressTest
 
     private String alreadyCompressedFilename;
     private String expectedContentType;
-    private CompressionType compressionType;
+    private String compressionType;
 
-    public GzipFilterDefaultNoRecompressTest(String testFilename, String expectedContentType, CompressionType compressionType)
+    public GzipFilterDefaultNoRecompressTest(String testFilename, String expectedContentType, String compressionType)
     {
         this.alreadyCompressedFilename = testFilename;
         this.expectedContentType = expectedContentType;
diff --git a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterDefaultTest.java b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterDefaultTest.java
index 47f637150cd..6c6faba5198 100644
--- a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterDefaultTest.java
+++ b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterDefaultTest.java
@@ -10,8 +10,7 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
 import org.eclipse.jetty.http.HttpStatus;
-import org.eclipse.jetty.http.gzip.CompressionType;
-import org.eclipse.jetty.http.gzip.GzipResponseWrapperImpl;
+import org.eclipse.jetty.http.gzip.CompressedResponseWrapper;
 import org.eclipse.jetty.servlet.DefaultServlet;
 import org.eclipse.jetty.servlet.FilterHolder;
 import org.eclipse.jetty.servlets.gzip.GzipTester;
@@ -29,20 +28,20 @@ import org.junit.runners.Parameterized.Parameters;
 public class GzipFilterDefaultTest
 {
     @Parameters
-    public static Collection<CompressionType[]> data()
+    public static Collection<String[]> data()
     {
-        CompressionType[][] data = new CompressionType[][]
+        String[][] data = new String[][]
                 {
-                { CompressionType.GZIP },
-                { CompressionType.DEFLATE } 
+                { GzipFilter.GZIP },
+                { GzipFilter.DEFLATE } 
                 };
         
         return Arrays.asList(data);
     }
     
-    private CompressionType compressionType;
+    private String compressionType;
     
-    public GzipFilterDefaultTest(CompressionType compressionType)
+    public GzipFilterDefaultTest(String compressionType)
     {
         this.compressionType = compressionType;
     }
@@ -80,7 +79,7 @@ public class GzipFilterDefaultTest
         GzipTester tester = new GzipTester(testingdir, compressionType);
 
         // Test content that is smaller than the buffer.
-        int filesize = GzipResponseWrapperImpl.DEFAULT_BUFFER_SIZE / 4;
+        int filesize = CompressedResponseWrapper.DEFAULT_BUFFER_SIZE / 4;
         tester.prepareServerFile("file.txt",filesize);
         
         FilterHolder holder = tester.setContentServlet(org.eclipse.jetty.servlet.DefaultServlet.class);
@@ -103,7 +102,7 @@ public class GzipFilterDefaultTest
         GzipTester tester = new GzipTester(testingdir, compressionType);
 
         // Test content that is smaller than the buffer.
-        int filesize = GzipResponseWrapperImpl.DEFAULT_BUFFER_SIZE * 4;
+        int filesize = CompressedResponseWrapper.DEFAULT_BUFFER_SIZE * 4;
         tester.prepareServerFile("file.txt",filesize);
         
         FilterHolder holder = tester.setContentServlet(org.eclipse.jetty.servlet.DefaultServlet.class);
@@ -126,7 +125,7 @@ public class GzipFilterDefaultTest
         GzipTester tester = new GzipTester(testingdir, compressionType);
 
         // Test content that is smaller than the buffer.
-        int filesize = GzipResponseWrapperImpl.DEFAULT_BUFFER_SIZE * 4;
+        int filesize = CompressedResponseWrapper.DEFAULT_BUFFER_SIZE * 4;
         tester.prepareServerFile("file.mp3",filesize);
         
         FilterHolder holder = tester.setContentServlet(org.eclipse.jetty.servlet.DefaultServlet.class);
@@ -173,7 +172,7 @@ public class GzipFilterDefaultTest
         holder.setInitParameter("excludedAgents", "foo");
         tester.setUserAgent("foo");
         
-        int filesize = GzipResponseWrapperImpl.DEFAULT_BUFFER_SIZE * 4;
+        int filesize = CompressedResponseWrapper.DEFAULT_BUFFER_SIZE * 4;
         tester.prepareServerFile("file.txt",filesize);
         
         try
diff --git a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipWithPipeliningTest.java b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipWithPipeliningTest.java
index 65a66898fc4..4144b0702d1 100644
--- a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipWithPipeliningTest.java
+++ b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipWithPipeliningTest.java
@@ -18,7 +18,6 @@ import java.util.regex.Pattern;
 import java.util.zip.GZIPInputStream;
 import java.util.zip.InflaterInputStream;
 
-import org.eclipse.jetty.http.gzip.CompressionType;
 import org.eclipse.jetty.server.Connector;
 import org.eclipse.jetty.server.Server;
 import org.eclipse.jetty.servlet.DefaultServlet;
@@ -50,10 +49,10 @@ public class GzipWithPipeliningTest
         // Test different Content-Encoding header combinations. So implicitly testing that gzip is preferred oder deflate
         String[][] data = new String[][]
                 {
-                { CompressionType.GZIP.getEncodingHeader() },
-                { CompressionType.DEFLATE.getEncodingHeader() + ", " + CompressionType.GZIP.getEncodingHeader() },
-                { CompressionType.GZIP.getEncodingHeader() + ", " + CompressionType.DEFLATE.getEncodingHeader() },
-                { CompressionType.DEFLATE.getEncodingHeader() } 
+                { GzipFilter.GZIP },
+                { GzipFilter.DEFLATE + ", " + GzipFilter.GZIP },
+                { GzipFilter.GZIP + ", " + GzipFilter.DEFLATE },
+                { GzipFilter.DEFLATE } 
                 };
         
         return Arrays.asList(data);
@@ -137,7 +136,7 @@ public class GzipWithPipeliningTest
 
             respHeader = client.readResponseHeader();
             System.out.println("Response Header #1 --\n" + respHeader);
-            String expectedEncodingHeader = encodingHeader.equals(CompressionType.DEFLATE.getEncodingHeader()) ? CompressionType.DEFLATE.getEncodingHeader() : CompressionType.GZIP.getEncodingHeader();
+            String expectedEncodingHeader = encodingHeader.equals(GzipFilter.DEFLATE) ? GzipFilter.DEFLATE : GzipFilter.GZIP;
             assertThat("Content-Encoding should be gzipped",respHeader,containsString("Content-Encoding: " + expectedEncodingHeader + "\r\n"));
             assertThat("Transfer-Encoding should be chunked",respHeader,containsString("Transfer-Encoding: chunked\r\n"));
 
@@ -182,7 +181,7 @@ public class GzipWithPipeliningTest
             IO.close(rawOutputStream);
             FileInputStream rawInputStream = new FileInputStream(rawOutputFile);
             InputStream uncompressedStream = null;
-            if (CompressionType.DEFLATE.getEncodingHeader().equals(encodingHeader))
+            if (GzipFilter.DEFLATE.equals(encodingHeader))
             {
                 uncompressedStream = new InflaterInputStream(rawInputStream);
             }
diff --git a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/IncludableGzipFilterMinSizeTest.java b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/IncludableGzipFilterMinSizeTest.java
index e12abff667a..6d37b0f1e6d 100644
--- a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/IncludableGzipFilterMinSizeTest.java
+++ b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/IncludableGzipFilterMinSizeTest.java
@@ -18,7 +18,6 @@ import java.util.Collection;
 
 import javax.servlet.Servlet;
 
-import org.eclipse.jetty.http.gzip.CompressionType;
 import org.eclipse.jetty.servlet.FilterHolder;
 import org.eclipse.jetty.servlets.gzip.GzipTester;
 import org.eclipse.jetty.servlets.gzip.TestMinGzipSizeServlet;
@@ -39,18 +38,18 @@ import org.junit.runners.Parameterized.Parameters;
 public class IncludableGzipFilterMinSizeTest
 {
     @Parameters
-    public static Collection<CompressionType[]> data()
+    public static Collection<String[]> data()
     {
-        CompressionType[][] data = new CompressionType[][]
+        String[][] data = new String[][]
                 {
-                { CompressionType.GZIP },
-                { CompressionType.DEFLATE } 
+                { GzipFilter.GZIP },
+                { GzipFilter.DEFLATE } 
                 };
         
         return Arrays.asList(data);
     }
     
-    public IncludableGzipFilterMinSizeTest(CompressionType compressionType)
+    public IncludableGzipFilterMinSizeTest(String compressionType)
     {
         this.compressionType = compressionType;
     }
@@ -58,7 +57,7 @@ public class IncludableGzipFilterMinSizeTest
     @Rule
     public TestingDir testdir = new TestingDir();
 
-    private CompressionType compressionType;
+    private String compressionType;
     private Class<? extends Servlet> testServlet = TestMinGzipSizeServlet.class;
 
     @Test
diff --git a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/IncludableGzipFilterTest.java b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/IncludableGzipFilterTest.java
index 49459e4e2ef..9872c198014 100644
--- a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/IncludableGzipFilterTest.java
+++ b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/IncludableGzipFilterTest.java
@@ -29,7 +29,6 @@ import java.util.zip.InflaterInputStream;
 
 import javax.servlet.http.HttpServletResponse;
 
-import org.eclipse.jetty.http.gzip.CompressionType;
 import org.eclipse.jetty.io.ByteArrayBuffer;
 import org.eclipse.jetty.servlet.FilterHolder;
 import org.eclipse.jetty.testing.HttpTester;
@@ -48,12 +47,12 @@ import org.junit.runners.Parameterized.Parameters;
 public class IncludableGzipFilterTest
 {
     @Parameters
-    public static Collection<CompressionType[]> data()
+    public static Collection<String[]> data()
     {
-        CompressionType[][] data = new CompressionType[][]
+        String[][] data = new String[][]
                 {
-                { CompressionType.GZIP },
-                { CompressionType.DEFLATE } 
+                { GzipFilter.GZIP },
+                { GzipFilter.DEFLATE } 
                 };
         
         return Arrays.asList(data);
@@ -77,9 +76,9 @@ public class IncludableGzipFilterTest
         "et cursus magna. Donec orci enim, molestie a lobortis eu, imperdiet vitae neque.";
 
     private ServletTester tester;
-    private CompressionType compressionType;
+    private String compressionType;
     
-    public IncludableGzipFilterTest(CompressionType compressionType)
+    public IncludableGzipFilterTest(String compressionType)
     {
         this.compressionType = compressionType;
     }
@@ -121,7 +120,7 @@ public class IncludableGzipFilterTest
         request.setMethod("GET");
         request.setVersion("HTTP/1.0");
         request.setHeader("Host","tester");
-        request.setHeader("accept-encoding", compressionType.getEncodingHeader());
+        request.setHeader("accept-encoding", compressionType);
         request.setURI("/context/file.txt");
         
         ByteArrayBuffer reqsBuff = new ByteArrayBuffer(request.generate().getBytes());
@@ -129,16 +128,16 @@ public class IncludableGzipFilterTest
         response.parse(respBuff.asArray());
                 
         assertTrue(response.getMethod()==null);
-        assertTrue(response.getHeader("Content-Encoding").equalsIgnoreCase(compressionType.getEncodingHeader()));
+        assertTrue(response.getHeader("Content-Encoding").equalsIgnoreCase(compressionType));
         assertEquals(HttpServletResponse.SC_OK,response.getStatus());
         
         InputStream testIn = null;
         ByteArrayInputStream compressedResponseStream = new ByteArrayInputStream(response.getContentBytes());
-        if (compressionType.equals(CompressionType.GZIP))
+        if (compressionType.equals(GzipFilter.GZIP))
         {
             testIn = new GZIPInputStream(compressedResponseStream);
         }
-        else if (compressionType.equals(CompressionType.DEFLATE))
+        else if (compressionType.equals(GzipFilter.DEFLATE))
         {
             testIn = new InflaterInputStream(compressedResponseStream);
         }
diff --git a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/gzip/GzipTester.java b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/gzip/GzipTester.java
index 91cc374c893..36cec8037b9 100644
--- a/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/gzip/GzipTester.java
+++ b/jetty-servlets/src/test/java/org/eclipse/jetty/servlets/gzip/GzipTester.java
@@ -25,7 +25,6 @@ import java.util.zip.InflaterInputStream;
 import javax.servlet.Servlet;
 import javax.servlet.http.HttpServletResponse;
 
-import org.eclipse.jetty.http.gzip.CompressionType;
 import org.eclipse.jetty.io.ByteArrayBuffer;
 import org.eclipse.jetty.servlet.FilterHolder;
 import org.eclipse.jetty.servlet.ServletHolder;
@@ -44,9 +43,9 @@ public class GzipTester
     private String userAgent = null;
     private ServletTester servletTester;
     private TestingDir testdir;
-    private CompressionType compressionType;
+    private String compressionType;
 
-    public GzipTester(TestingDir testingdir, CompressionType compressionType)
+    public GzipTester(TestingDir testingdir, String compressionType)
     {
         this.testdir = testingdir;
         this.compressionType = compressionType;
@@ -68,7 +67,7 @@ public class GzipTester
         request.setMethod("GET");
         request.setVersion("HTTP/1.0");
         request.setHeader("Host","tester");
-        request.setHeader("Accept-Encoding",compressionType.getEncodingHeader());
+        request.setHeader("Accept-Encoding",compressionType);
         if (this.userAgent != null)
             request.setHeader("User-Agent", this.userAgent);
         request.setURI("/context/" + requestedFilename);
@@ -83,7 +82,7 @@ public class GzipTester
         Assert.assertThat("Response.method",response.getMethod(),nullValue());
         Assert.assertThat("Response.status",response.getStatus(),is(HttpServletResponse.SC_OK));
         Assert.assertThat("Response.header[Content-Length]",response.getHeader("Content-Length"),notNullValue());
-        Assert.assertThat("Response.header[Content-Encoding]",response.getHeader("Content-Encoding"),containsString(compressionType.getEncodingHeader()));
+        Assert.assertThat("Response.header[Content-Encoding]",response.getHeader("Content-Encoding"),containsString(compressionType));
 
         // Assert that the decompressed contents are what we expect.
         File serverFile = testdir.getFile(serverFilename);
@@ -96,11 +95,11 @@ public class GzipTester
         try
         {
             bais = new ByteArrayInputStream(response.getContentBytes());
-            if (compressionType.equals(CompressionType.GZIP))
+            if (compressionType.equals(GzipFilter.GZIP))
             {
                 in = new GZIPInputStream(bais);
             }
-            else if (compressionType.equals(CompressionType.DEFLATE))
+            else if (compressionType.equals(GzipFilter.DEFLATE))
             {
                 in = new InflaterInputStream(bais);
             }
@@ -142,7 +141,7 @@ public class GzipTester
         request.setMethod("GET");
         request.setVersion("HTTP/1.0");
         request.setHeader("Host","tester");
-        request.setHeader("Accept-Encoding",compressionType.getEncodingHeader());
+        request.setHeader("Accept-Encoding",compressionType);
         if (this.userAgent != null)
             request.setHeader("User-Agent", this.userAgent);
         request.setURI("/context/" + requestedFilename);
@@ -229,7 +228,7 @@ public class GzipTester
         request.setMethod("GET");
         request.setVersion("HTTP/1.0");
         request.setHeader("Host","tester");
-        request.setHeader("Accept-Encoding",compressionType.getEncodingHeader());
+        request.setHeader("Accept-Encoding",compressionType);
         if (this.userAgent != null)
             request.setHeader("User-Agent", this.userAgent);
         if (filename == null)
@@ -252,7 +251,7 @@ public class GzipTester
             int serverLength = Integer.parseInt(response.getHeader("Content-Length"));
             Assert.assertThat("Response.header[Content-Length]",serverLength,is(expectedFilesize));
         }
-        Assert.assertThat("Response.header[Content-Encoding]",response.getHeader("Content-Encoding"),not(containsString(compressionType.getEncodingHeader())));
+        Assert.assertThat("Response.header[Content-Encoding]",response.getHeader("Content-Encoding"),not(containsString(compressionType)));
 
         // Assert that the contents are what we expect.
         if (filename != null)