void receiveHeaders(List<String> headers, HeadersMode headersMode) {
assert (!Thread.holdsLock(SpdyStream.this));
ErrorCode errorCode = null;
boolean open = true;
synchronized (this) {
if (responseHeaders == null) {
if (headersMode.failIfHeadersAbsent()) {
errorCode = ErrorCode.PROTOCOL_ERROR;
} else {
responseHeaders = headers;
open = isOpen();
notifyAll();
}
} else {
if (headersMode.failIfHeadersPresent()) {
errorCode = ErrorCode.STREAM_IN_USE;
} else {
List<String> newHeaders = new ArrayList<String>();
newHeaders.addAll(responseHeaders);
newHeaders.addAll(headers);
this.responseHeaders = newHeaders;
}
}
}
if (errorCode != null) {
closeLater(errorCode);
} else if (!open) {
connection.removeStream(id);
}
}
void receiveHeaders(List<Header> paramList, HeadersMode paramHeadersMode)
{
assert (!Thread.holdsLock(this));
Object localObject = null;
boolean bool = true;
label97:
do
{
for (;;)
{
try
{
if (this.responseHeaders == null)
{
if (paramHeadersMode.failIfHeadersAbsent())
{
paramList = ErrorCode.PROTOCOL_ERROR;
if (paramList == null) {
break;
}
closeLater(paramList);
return;
}
this.responseHeaders = paramList;
bool = isOpen();
notifyAll();
paramList = (List<Header>)localObject;
continue;
}
if (!paramHeadersMode.failIfHeadersPresent()) {
break label97;
}
}
finally {}
paramList = ErrorCode.STREAM_IN_USE;
continue;
paramHeadersMode = new ArrayList();
paramHeadersMode.addAll(this.responseHeaders);
paramHeadersMode.addAll(paramList);
this.responseHeaders = paramHeadersMode;
paramList = (List<Header>)localObject;
}
} while (bool);
this.connection.removeStream(this.id);
}
@Override
public void headers(
boolean outFinished,
boolean inFinished,
int streamId,
int associatedStreamId,
int priority,
List<Header> headerBlock,
HeadersMode headersMode) {
if (pushedStream(streamId)) {
pushHeadersLater(streamId, headerBlock, inFinished);
return;
}
SpdyStream stream;
synchronized (SpdyConnection.this) {
// If we're shutdown, don't bother with this stream.
if (shutdown) return;
stream = getStream(streamId);
if (stream == null) {
// The headers claim to be for an existing stream, but we don't have one.
if (headersMode.failIfStreamAbsent()) {
writeSynResetLater(streamId, ErrorCode.INVALID_STREAM);
return;
}
// If the stream ID is less than the last created ID, assume it's already closed.
if (streamId <= lastGoodStreamId) return;
// If the stream ID is in the client's namespace, assume it's already closed.
if (streamId % 2 == nextStreamId % 2) return;
// Create a stream.
final SpdyStream newStream =
new SpdyStream(
streamId, SpdyConnection.this, outFinished, inFinished, priority, headerBlock);
lastGoodStreamId = streamId;
streams.put(streamId, newStream);
executor.submit(
new NamedRunnable("OkHttp %s stream %d", hostName, streamId) {
@Override
public void execute() {
try {
handler.receive(newStream);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
});
return;
}
}
// The headers claim to be for a new stream, but we already have one.
if (headersMode.failIfStreamPresent()) {
stream.closeLater(ErrorCode.PROTOCOL_ERROR);
removeStream(streamId);
return;
}
// Update an existing stream.
stream.receiveHeaders(headerBlock, headersMode);
if (inFinished) stream.receiveFin();
}
