The driver sends us back one of three transaction completion messages
BR_TRANSACTION_COMPLETE, BR_DEAD_REPLY or BR_FAILED_REPLY after the
target has finished processing BC_REPLY. It's especially important
when the reply carries an object reference. That gives the other side
a chance to reference that object before we drop our reference to it
(which may be the last one, which would cause the object to be freed
and its handle invalidated).

This transaction flag doesn't make sense for replies and is probably
just ignored but let's not confuse kernel.

Otherwise all kinds of race conditions are possible, e.g. with
GBinderServiceManager and its gbinder_servicemanager_died() callback.

That's done by calling test_binder_exit_wait(). Not doing so occasionally
breaks the next unit test.

It's always zero, just leave it as is.

Only affects debug build.

Add GBinderBridge

It acts as a proxy between two binder devices.

This version works for binder transactions which only
pass serialized data back and forth. Passing remote
object references is not yet supported.

This more or less ensures that responses get handled by the right thread
and allows to simulate more sophisticated test cases.

If there's no data, buffer may be NULL.

Fix a threading issue + assorted changes

Make sure that transaction handlers don't get invoked on a worker thread.
It was possible in cases if an incoming transaction arrives while we are
waiting for response from an asynchronous call to servicemanager (which
is actually a synchronous call made on a worker thread).

Invoking callbacks on a worker thread would completely break libgbinder's
synchronization model. It was a pretty unlikely scenario, though.

GBinderFds - native_handle_t
GBinderHidlHandle - struct hidl_handle
GBinderHidlMemory - struct hidl_memory

Except for one-way transactions where it would meaningless.

For better compile time diagnostics.

Also made ServiceManagerAidl a GBinderLocalObject-derived class to prepare
for possibly making it (deriving classes from GBinderLocalObject) a public
functionality.

It's something I've always had in mind. It's still an internal API
but it's quite likely that at some point it will be made public.
For now it's only going to be used by unit tests.

Fix random unit text failures

If a test calls test_binder_set_looper_enabled(fd, TRUE) to enable
processing of incoming data by the looper thread, the same thread
may get picked up by the next test and swallow the reply before the
transaction (for which the reply was intended) has been submitted.
Which may cause that next test to either fail or (if the transaction
was synchronous) block forever, stalling the build.

Calling gbinder_ipc_exit() makes sure that looper thread terminates
before the next test starts.

Use condition variable to signal closure of the last descriptor.

A few minor tweaks and another unit test

We must have looper running in order to receive death notifications.

And refactored binder simulator, it can now simulate a lot
more sophisticated scenarious.