Method onHeadersBufferWritten

Libraries/Http/HttpAsyncClient.cpp:598–687

    ::memset(currentHostStorage, 0, sizeof(currentHostStorage));
    ::memcpy(currentHostStorage, currentURL.host.bytesWithoutTerminator(), hostLen);
    currentHost = StringSpan::fromNullTerminated(currentHostStorage, StringEncoding::Ascii);
    currentPort = currentURL.port;
    return Result(true);
}

void HttpAsyncClient::completeTransportSetup(Result result)
{
    if (state != State::Connecting or connection == nullptr)
    {
        return;
    }
    if (not result)
    {
        fail(result);
        return;
    }

    const bool addedReadableError =
        connection->getReadableTransportStream()
            .eventError.addListener<HttpAsyncClient, &HttpAsyncClient::onReadableError>(*this);
    const bool addedWritableError =
        connection->getWritableTransportStream()
            .eventError.addListener<HttpAsyncClient, &HttpAsyncClient::onWritableError>(*this);
    const bool addedReadableEnd =
        connection->getReadableTransportStream().eventEnd.addListener<HttpAsyncClient, &HttpAsyncClient::onReadableEnd>(
            *this);
    const bool addedPipelineError =
        connection->pipeline.eventError.addListener<HttpAsyncClient, &HttpAsyncClient::onPipelineError>(*this);
    SC_HTTP_ASSERT_RELEASE(addedReadableError);
    SC_HTTP_ASSERT_RELEASE(addedWritableError);
    SC_HTTP_ASSERT_RELEASE(addedReadableEnd);
    SC_HTTP_ASSERT_RELEASE(addedPipelineError);

    Result origin = rememberConnectedOrigin();
    if (not origin)
    {
        fail(origin);
        return;
    }

    hasOpenConnection = true;

    Result responseStart = beginResponseRead();
    if (not responseStart)
    {
        fail(responseStart);
        return;
    }
    Result sendResult = beginRequestSend();
    if (not sendResult)
    {
        fail(sendResult);
    }
}

Result HttpAsyncClient::beginResponseRead()
{
    const bool addedResponseData = connection->getReadableTransportStream()