libbnetapi: BUrlRequest now outputs to BDataIO

Previously, BUrlRequest returns data received via a callback that can't
return any value. This approach have several issues:

- It's not possible to signify failures to the request.
- Users have to implement custom listeners just to handle the common
case of outputting to a buffer/file/etc.
- The received data has to be serialized into BMessage when
BUrlProtocolDispatchingListener is employed. This can cause a
noticible slowdown in real-world scenarios as evident by #10748.

With this change, BUrlRequest will output directly into a BDataIO, which
exposes a richer API for request handlers to work with (for example a
BitTorrent client can request a BPositionIO for non-linear data
delivery), as well as simplifying common cases for users.

The adaptation only requires one additional API:
BHttpRequest::SetStopOnError(). This API simply instructs the HTTP
request handler to cancel the request if an HTTP error is occurred.

Change-Id: I4160884d77bff0e7678e0a623e2587987704443a
Reviewed-on: https://review.haiku-os.org/c/haiku/+/3084
Reviewed-by: Adrien Destugues <pulkomandy@gmail.com>

libbnetservices: BUrlResult is no longer a BArchivable

The switch to make BUrlResult serializable was debuted in
f9e1854f198d4200f21a9cbe29fdfb0fabbe192f with the rationale is that
BHttpRequest auto-redirection might cause the headers to become
obsolete by the time a client process the BMessage received from
BUrlProtocolDispatchingListener.

With the change to BHttpRequest to not notify listeners when
auto-redirection is enabled, this is no longer the case and the
serialization code can go away now. This simplifies BUrlResult and its
subclasses, and gain us some performance for clients using
BUrlProtocolDispatchingListener as the result object no longer has to be
serialized.

This also change the ABI of BUrlProtocolListener::HeadersReceived to no
longer passing a BUrlResult.

Additionally, BUrlResult and BHttpResult now express the size of the content
as an off_t, thus allowing results larger than 4 GB.

Change-Id: I9dd29a8b26fdd9aa8e5bbad8d1728084f136312d
Reviewed-on: https://review.haiku-os.org/c/haiku/+/3082
Reviewed-by: Adrien Destugues <pulkomandy@gmail.com>

http_streamer: switch to libnetservices.a

Switch to the experimental services API as the copy in libbnetapi.so is
deprecated.

Change-Id: I57d76b1d1be5c957221cc2d77d148fadbac2a642
Reviewed-on: https://review.haiku-os.org/c/haiku/+/3668
Reviewed-by: Adrien Destugues <pulkomandy@gmail.com>

HTTPStreamer: Another build fix I forgot to commit.

Sorry for the noise...

Revert the Codec Kit.

All of Barrett's individual reverts have been squashed into this
one commit, save a few actual bugfixes.

Change-Id: Ib0a7d0a841d3ac40b1fca7372c58b7f9229bd1f0

media_plugins: Rework to use the BCodecKit namespace

http_streamer: Use MediaDebug.h

FileListener: does not need to be asynchronous.

The asynchronous listener is meant to be used when the functions are
meant to be called from the main thread (or another looper the listener
is explicitly atached to).

For this to work, the request should be attached to
listener->SynchronousListener(), which was not the case here. Assume it
is fine for the functions to be called from the HTTP thread directly
then (if I'm wrong, revert this and attach the synchronous listener to
the http request, however wihout further changes it will just move the
execution of the callbacks to the main thread, which may not be the
right place either).

This fixes a crash when exiting WebKit while playing a youtube video
(somehow the handler isn't cleanly deleted and removed from the main
looper there - going without a handler at all fixes this).

Fix some users of the HTTP API I missed in the previous commit.

style fix.

HTTP media IO: fix another case of crash.

HTTPMediaIO: fix crash on exit.

- Remove custom BUrlContext, use the shared one to simplify ownership
management. This means all HTTP media streams in an application share
the same context (including cookies), however.
- Fix deletion of the BUrlRequest object, which cannot reliably happen
before the thread has exited. RequestCompleted is too early.

http_streamer: don't access headers before HeadersReceived.

UpdateSize uses HttpResult::Length, which relies on the
contetn-length header to be already received from the server. Doing it
in ConnectionOpened will not work. Doing it from HeadersReceived, which
is called a bit later, will work.

This allows using the http_streamer in webkit for youtube video playing,
and should fix all uses with a fixed size resource (rather than an
endless stream).

http_streamer: improve IsRunning() safeness

http_streamer: Fix different issues

* Cleanup object management.
* Remove Close() and use the destructor in place.
* Release listener sem on exit.
* Return when there's a request mismatch.
* Add some debugging.
* MediaPlayer crashes are fixed as result of the patchset.

http_streamer: Don't always use listener's IsRunning

* We are not really handling http requests only.
* Also move BHttpResult retrieve after casting BUrlRequest.

http_streamer: Handle http status codes

* Avoid to stop the next request after redirection.
* Fixes #12854.

http_streamer: Enforce safeness in constructor/thread

* Wait for the thread to exit.
* Update size from the data thread.

http_streamer: Implement IsRunning, more reliability

* The init sem is released also when the request is completed
to be sure the backend doesn't lock on us.
* Implement IsRunning relying on BUrlRequest::IsRunning.

AdapterIO: Remove default arguments in ctor

http_streamer: Mutable flag is chosen at runtime

* BeOS Radio now works.

http_streamer: Refine init, set static timeout

* When in Open() the plugin wait for the first buffer
or return an error if timeout expires.
* Make size retrieve more reliable.

Style fixes

http_streamer: Sync with BAdapterIO changes

http_streamer: Handle Run() failed

http_streamer: Check request after creation

* Thanks to DeadYak for the help.

Streaming: Remove any pointer BUrl argument

* There's no need to pass BUrl by pointer, this is
potentially dangerous and leaky without any advantage,
copying is definitely safer.

http_streamer: Style fixes and cleanup

HTTPMediaIO: Implement SetSize and GetSize

* SetSize requests are denied where GetSize return the request
lengths. Note that flags are changed accordingly.

http_streamer: General refactor making use of new API

* Use BUrlProtocolRoster instead of BFileRequest.
* Removed HTTPMediaIO custom code that now inherits
BAdapterIO and make the whole thing more simple.
* It work with some formats (flv, mp3, mkv) but ffmpeg fail
on others (mp4, 3gp).
* GetSize needs improvements.

http_streamer: Add basic draft version