Attachment #31618 for bug #56521

View | Details | Raw Unified | Return to bug 56521
Collapse All | Expand All




    private volatile WriteListener listener = null;
    private volatile boolean fireListener = false;
    private volatile byte[] buffer;
    private volatile int bufferUsed = 0;
    private static final int BUFFER_SIZE_LIMIT = 32768;

    /**
     * New Servlet 3.1 method.

        // Make sure isReady() and onWritePossible() have a consistent view of
        // buffer and fireListener when determining if the listener should fire
        synchronized (fireListenerLock) {
            boolean result = (buffer == null);
            fireListener = !result;
            return result;
        }

    }

    private void preWriteChecks() {
        if (buffer != null) {
            throw new IllegalStateException(
                    sm.getString("upgrade.sis.write.ise"));
        }

            // write executes.
            int written = doWrite(false, b, off, len);
            if (written < len) {
                // TODO: - Reuse the buffer
                //       - Only reallocate if it gets too big (>8k?)
                buffer = new byte[len - written];
                System.arraycopy(b, off + written, buffer, 0, len - written);
                } else if ( buffer.length > BUFFER_SIZE_LIMIT && bufferUsed <= BUFFER_SIZE_LIMIT ){
                		buffer = new byte[BUFFER_SIZE_LIMIT];
                }
                System.arraycopy(b, off + written, buffer, 0, bufferUsed);
            } else {
                buffer = null;
            }
        }
    }

    protected final void onWritePossible() throws IOException {
        synchronized (writeLock) {
            try {
                writeInternal(buffer, 0, buffer.length);
            } catch (Throwable t) {
                ExceptionUtils.handleThrowable(t);
                listener.onError(t);

            boolean fire = false;

            synchronized (fireListenerLock) {
                if (buffer == null && fireListener) {
                    fireListener = false;
                    fire = true;
                }

Return to bug 56521

Lines 40-47 Link Here

(-)AbstractServletOutputStream.java (-15 / +9 lines)
40	private volatile WriteListener listener = null;	40	private volatile WriteListener listener = null;
41	private volatile boolean fireListener = false;	41	private volatile boolean fireListener = false;
42	private volatile byte[] buffer;	42	private volatile byte[] buffer;
43	private volatile int bufferUsed = 0;
44	private static final int BUFFER_SIZE_LIMIT = 32768;
45		43
46	/**	44	/**
47	* New Servlet 3.1 method.	45	* New Servlet 3.1 method.
Lines 55-61 Link Here
55	// Make sure isReady() and onWritePossible() have a consistent view of	53	// Make sure isReady() and onWritePossible() have a consistent view of
56	// buffer and fireListener when determining if the listener should fire	54	// buffer and fireListener when determining if the listener should fire
57	synchronized (fireListenerLock) {	55	synchronized (fireListenerLock) {
58	boolean result = (bufferUsed == 0);	56	boolean result = (buffer == null);
59	fireListener = !result;	57	fireListener = !result;
60	return result;	58	return result;
61	}	59	}
Lines 101-107 Link Here
101	}	99	}
102		100
103	private void preWriteChecks() {	101	private void preWriteChecks() {
104	if (bufferUsed != 0) {	102	if (buffer != null) {
105	throw new IllegalStateException(	103	throw new IllegalStateException(
106	sm.getString("upgrade.sis.write.ise"));	104	sm.getString("upgrade.sis.write.ise"));
107	}	105	}
Lines 124-139 Link Here
124	// write executes.	122	// write executes.
125	int written = doWrite(false, b, off, len);	123	int written = doWrite(false, b, off, len);
126	if (written < len) {	124	if (written < len) {
127		125	// TODO: - Reuse the buffer
128	bufferUsed = len - written;	126	// - Only reallocate if it gets too big (>8k?)
129	if ( bufferUsed > buffer.length) {	127	buffer = new byte[len - written];
130	buffer = new byte[bufferUsed];	128	System.arraycopy(b, off + written, buffer, 0, len - written);
131	} else if ( buffer.length > BUFFER_SIZE_LIMIT && bufferUsed <= BUFFER_SIZE_LIMIT ){
132	buffer = new byte[BUFFER_SIZE_LIMIT];
133	}
134	System.arraycopy(b, off + written, buffer, 0, bufferUsed);
135	} else {	129	} else {
136	bufferUsed = 0;	130	buffer = null;
137	}	131	}
138	}	132	}
139	}	133	}
Lines 142-148 Link Here
142	protected final void onWritePossible() throws IOException {	136	protected final void onWritePossible() throws IOException {
143	synchronized (writeLock) {	137	synchronized (writeLock) {
144	try {	138	try {
145	writeInternal(buffer, 0, bufferUsed);	139	writeInternal(buffer, 0, buffer.length);
146	} catch (Throwable t) {	140	} catch (Throwable t) {
147	ExceptionUtils.handleThrowable(t);	141	ExceptionUtils.handleThrowable(t);
148	listener.onError(t);	142	listener.onError(t);
Lines 158-164 Link Here
158	boolean fire = false;	152	boolean fire = false;
159		153
160	synchronized (fireListenerLock) {	154	synchronized (fireListenerLock) {
161	if (bufferUsed == 0 && fireListener) {	155	if (buffer == null && fireListener) {
162	fireListener = false;	156	fireListener = false;
163	fire = true;	157	fire = true;
164	}	158	}