The main motivation here is to make sure we don't %-escape incoming pluses, but rather interpret them as spaces.

These are almost the same as {encode,decode}UriComponent, differing only in the set of characters they consider reserved, and their treatment of spaces.

I wasn't sure what to name them -- encodeWwwForm() seemed least bad.

For the encode side, I added a completely separate function -- it seemed like more trouble than it was worth trying to integrate the changes into encodeUriComponent(). For the decode side, I integrated the change (plus-to-space) into decodeBinaryUriComponent(), since that function is a bit longer, and the change was trivial.

Add option to omit default-valued primitives from JSON output.

Fix bug where DNS lookup would fail for very long hostnames.

Add Array::attach() and ArrayPtr::attach().

Array::attach() is like Own::attach().

ArrayPtr::attach() promotes an ArrayPtr to an Array by attaching other objects to it. (Hopefully one of those objects actually owns the underlying array data.)

Allow working around the message size limit

Treat 'Premature EOF' error on async stream as DISCONNECTED.

Unfortunately TCP does not always distinguish between dirty connection failure and clean connection shutdown. In practice, though, "Premature EOF" errors on streams basically always appear to be due to disconnects (including when the peer crashes).

 Refactor handling of connection-level headers.

The headers for multiple responses could end up merged because the call to headers.clear() was happening too early. This manifested as `Content-Length: 7, 13` observed in the second pipelined response.

Although applications in theory shouldn't care to see connection-level headers (e.g. `Transfer-Encoding`), higher-level specs like the JavaScript Fetch API often specify that these headers should be visible, and they can be useful for debugging. So, this change makes it so that the application can see the connection-level headers on incoming requests.

For outgoing requests, the application can provide an HttpHeaders object that specifies these headers (important especially for the pass-through case), but the HTTP implementation will ignore them.

Additionally, we can now allow the application to set WebSocket connection-level headers on non-WebSocket requests. This is useful for frameworks that emulate WebSocket over HTTP and assume the ability to set WebSocket headers (especially `Sec-WebSocket-Extension`) on regular non-WebSocket HTTP requests.

Silence compiler warning about non-virtual dtor on non-final classes

Make AsyncUnixTest/InterruptedTimer slower on Linux becaues it turns out to be flaky on machines other than mine.

Replace all include guards with #pragma once.

@kloepper pointed out a while back that every compiler you've ever heard of supports this. Plus, it's more concise, it's not prone to copy-paste errors, and it looks nicer.

At the time I wanted to remain consistent and I didn't feel like spending the time to update all my existing code. But, every time I've added a new header since I've cursed the include guard, so I finally broke down and changed it.

Fix wrong poll/epoll timeout after EINTR.

Fix capnp_generate_cpp usage of --src-prefix

Various tweaks needed by Sandstorm HTTP changes

This gives Sandstorm a way to move the membrane to a different process when desired.

Add totalSize() to list readers, like struct readers.

Extend membrane framework to make revocation easy.

I realized upon trying to use this framework in Sandstorm that proper revocation was not easy to implement as-is. It's easy enough to revoke new calls, but canceling existing calls requires implementing a custom RequestHook and such. Since revocation is arguably the most important thing one might want to do with a membrane, this should be built-in.