evas: disable del hook when pushed inside the hash.

This is necessary in case of cycling init/shutdown as the hash will
destroy the Event, but the hook will instantly reinsert it.

eo: match raise of error level in tests.

eo: we are actually testing internal function too here.

eo: add infrastructure to test critical Eina Error.

eo: improve tests suite debugging by always displaying the error message before abort.

eo: move wref set to NULL to append after last event.

Making wref disapear before the last event require additional work to use
them during the FREE event. As I think we should introduce a wref that
disapear after the invalidate state, it makes sense to move that to a later
stage. Especially because their is no specific event related to them
being set to NULL.

evas: improve test to actually test something meaningful.

elementary: fix configuration destruction by actually calling the proper way of destruction.

evas: actually we expect gradient to live as long as the part that is using them.

ecore_con: allow for NULL to do nothing.

elementary: the config subsystem expect a stringshare.

evas: multiple call to evas_object_del are allowed even after the first one succeeded.

eo: allow efl_part during object invalidate.

eo: remove parent_sink as this hack should not be necessary anymore.

eo: try to make efl_add and efl_add_ref refcounting sane in all case.

ecore_file: on shutdown properly set to NULL to avoid confusion when cycling init/shutdown.

ecore: allow for NULL file handler request.

elementary: destroy timer as they could tick during shutdown.

elementary: properly destroy block events object during destruction.

evas: do not crash if constructor fail and invalidate is run on a partial object.

eo: improve error reporting to display object pointer (without accessing it).

elementary: cleanup genlist destructor to order content destruction correctly.

evas: make evas_object_free work in case of lost reference to Eo object.

This is clearly a workaround to a bad situation, but there is no case
that I can find that solely lead to object being NULL nor is there any
code that should do that, but still it does in some case...

evas: detect incoherency in object content and report problem.

evas: handle Evas_Object constructor failure case better.

edje: simplify part handling as we are now guaranteed that a part as no parent when reaching the del intercept.

eo: make sure that reporting object refcount during efl_noref, doesn't lead to recursive loop.

eo: add warning in case of a terrible situation happen.

eo: efl_invalidate should also be triggered for object with no parent before the destructor.

ecore: properly cleanup variable on shutdown, so that cycling another init doesn't crash.

evas: improve evas child destruction order.

Technically I do not thing it is a correct behavior to force destroy
reference that evas do not hold, but evas_object are deaply tied to
the canvas they are build on and even after invalidate it is hard
to not have function call that would lead to crash. Making the pointer
incorrect thanks to eo indirection seems safer here.

evas: do not override lifecycle by overriding efl_parent_set.

evas: reindent code properly.

eo: actually enforcing the efl_parent_set code path is necessary to enforce the predictability of the code path.

eo: as efl_del is not an Eo API call anymore, manually protect call with refcount.

eo: update refcount before sending efl_noref event to avoid double update during events propagation.

ecore: because fd_handler do not have the main loop as parent, the main loop can die before them.

evas: move the del event to match invalidate and free event to the end of the destructor.

elementary: when there is no file listed yet, no need to request them.

eina: make it possible to return an EINA_VALUE_EMPTY by just requesting a new value of type NULL.

eina: check the type before looking at anything else to avoid triggering valgrind warning.

elementary: enforce walk to protect the object existence by using eo refcounting.

elementary: reorder operation to only call efl_parent_set when the object still has a chance to exist.

evas: destructor can not be called recursively, we should rely on Eo refcount.

eo: move destruction of the link with children to be always after invalidate.

eo: propagate invalidate before destroying the link to the parent.

evas: actually we do not even need to NULL it, if we wref it.

edje: do not reparent when the object is dead already.

eo: improve message for debugging life cycle issues.

edje: forgot to propagate invalidate upward.

cxx: Fix examples after part changes

Reviewed-by: Cedric BAIL <cedric@osg.samsung.com>

examples: Elm: Add dependency on efl.la due to efl_part

Reviewed-by: Cedric BAIL <cedric@osg.samsung.com>

efl_mono: Fixes after efl_part/del changes.

Reviewed-by: Cedric BAIL <cedric@osg.samsung.com>

ecore_evas: we shouldn't do anything when we are deleted.

evas: preserve evas_object_del logic to not really destroy an object until it is fully unref first.

evas: enforce legacy parent to be the canvas.

elementary: refactor by using elm_legacy_add.

evas: add a way to figure out the evas class that should be the real parent for all legacy object.

elementary: make toolbar 'more_item' properly self destruct.

elementary: no need to recalculate the layout during invalidate.

elementary: the pan object of the map object was created with efl_add, adjust accordingly.

elementary: due to lifecycle difference between legacy object and unified object, we need to track their lifecycle more explicitely.

It is my understanding that some items view are created with efl_add directly
and manipulate VIEW directly with Eo new API. This clash with the inconsistent
behavior that evas_object_del expect. To work around this, we track object life
by explictely relying on efl_wref_add while holding the pointer to the object.

eo: efl_del should not be something anyone can override this can break so many things.

Allowing override of efl_del allow for messing with object life cycle which can create
problem for binding where an object was expected to be invalidated, but isn't really.

evas: try to protect old legacy lifecycle without overloading Efl.Del.

eio: properly handle Eio.Model lifecycle inside Elm.Fileselector.

Differential Revision: https://phab.enlightenment.org/D6107

elementary: dayselector use efl_add to create the object, calling efl_del during destructor make no sense.

Differential Revision: https://phab.enlightenment.org/D6106

elementary: no need to check for part during destruction.

Differential Revision: https://phab.enlightenment.org/D6105

elementary: no need for resize an object during destruction.

Differential Revision: https://phab.enlightenment.org/D6104

elementary: colorselector item are created with efl_add, so they are dead when they reach the destructor.

Differential Revision: https://phab.enlightenment.org/D6103

evas: refactor efl_input_event and remove some of the lifecycle hack.

Differential Revision: https://phab.enlightenment.org/D6101

eo: actually during invalidating we already have an invalidated object.

Differential Revision: https://phab.enlightenment.org/D6100

eo: move EFL internal function ___efl_ref2 also to eo_internal.h

Differential Revision: https://phab.enlightenment.org/D6099

efl: major rewrite of efl_part.

The interface efl_part_get should not be directly called from C, but the efl_part
wrapper should. It rely on efl_noref to properly destroy the object. Binding can
control the lifecycle of the reference the way they want by either calling the
wrapper or efl_part_get directly. It also means that the ugly ___efl_auto_unref_set
doesn't need to be exposed outside of EFL anymore.

Differential Revision: https://phab.enlightenment.org/D6098

eo: check for allow_parent_unref during efl_unref and silence warning.

Differential Revision: https://phab.enlightenment.org/D6097

eo: make sure efl_noref is always called at the proper time.

Differential Revision: https://phab.enlightenment.org/D6096

eo: add an automatic fallback at the moment when efl_unref instead of efl_del is called.

Differential Revision: https://phab.enlightenment.org/D6095

elementary: object created with efl_add should be destroyed with efl_del.

Differential Revision: https://phab.enlightenment.org/D6094

elementary: object allocated with efl_add should be destroyed with efl_del.

Differential Revision: https://phab.enlightenment.org/D6093

eldbus: fix unref of eldbus to not throw warning all over the place.

Especially to note, that when giving a message to send, the caller
do not own it anymore and should not unref it.

Differential Revision: https://phab.enlightenment.org/D6092

eldbus: manage death of children during invalidate.

Differential Revision: https://phab.enlightenment.org/D6091

eldbus: object created with efl_add should be destroyed with efl_del.

Differential Revision: https://phab.enlightenment.org/D6090

ecore: first invalidate the loop and its children, then destroy all the object capability.

Differential Revision: https://phab.enlightenment.org/D6089

eo: optimize efl object reuse by limiting the amount of call to pointer translation.

Differential Revision: https://phab.enlightenment.org/D6088

edje: properly handle lifecycle of edje global object.x

Differential Revision: https://phab.enlightenment.org/D6087

eo: prevent parenting to an already invalidated parent.

Differential Revision: https://phab.enlightenment.org/D6086

eo: only call efl_parent_set(NULL) at the end of invalidate if the object is not invalidating.

Add also a comment to justify why we do force parent to NULL during invalidate.

Differential Revision: https://phab.enlightenment.org/D6085

ecore_con: correct lifecycle of object used by Efl.Net.Dialer.Ssl.

Differential Revision: https://phab.enlightenment.org/D6084

ecore_con: trigger teardown during invalidate.

Delaying teardown might result in code expecting parent to still be valid,
especially call to efl_provider_find won't work anymore.

Differential Revision: https://phab.enlightenment.org/D6083

ecore_con: it is best to call the super destructor and not touch the object anymore after.

Differential Revision: https://phab.enlightenment.org/D6082

ecore_con: correct a typo wrongly calling super destructor instead of super invalidate.

Differential Revision: https://phab.enlightenment.org/D6081

ecore: correct lifecycle of object used by Ecore_Con legacy.

Differential Revision: https://phab.enlightenment.org/D6080

eo: improve error message by pointing to the class that is creating trouble.

Differential Revision: https://phab.enlightenment.org/D6079

eo: preventing infinite loop by safely iterating over children during destructor.

Differential Revision: https://phab.enlightenment.org/D6078

ecore: properly handle shutdown of Efl.Loop children by using invalidate.

Differential Revision: https://phab.enlightenment.org/D6077

ecore: disable signal during shutdown.

Differential Revision: https://phab.enlightenment.org/D6076

eo: invalidate at the end of efl_invalidate only and prevent infinite recursion with an invalidating phase.

Differential Revision: https://phab.enlightenment.org/D6075

ecore: force close during invalidate of Efl.Io.Buffered_Stream.

Differential Revision: https://phab.enlightenment.org/D6074

elementary: use invalidate instead of overriding del for widget items.

Differential Revision: https://phab.enlightenment.org/D6073

elementary: rely on inheritance instead of faking efl_del behavior.

Differential Revision: https://phab.enlightenment.org/D6072

elementary: make del_pre not return a bool and force rely on Eo ref counting.

Differential Revision: https://phab.enlightenment.org/D6071