void ObjectHost::wrappedDisconnectedCallback(HostedObjectWPtr ho_weak, const SpaceObjectReference& sporef, Disconnect::Code cause, DisconnectedCallback cb) {
if (mQueryProcessor != NULL) {
HostedObjectPtr ho(ho_weak);
if (ho)
mQueryProcessor->presenceDisconnected(ho, sporef);
}
cb(sporef, cause);
}
void ObjectHost::wrappedStreamCreatedCallback(HostedObjectWPtr ho_weak, const SpaceObjectReference& sporef, SessionManager::ConnectionEvent after, StreamCreatedCallback cb) {
if (mQueryProcessor != NULL) {
HostedObjectPtr ho(ho_weak);
if (ho) {
SSTStreamPtr strm = getSpaceStream(sporef.space(), sporef.object());
// This had better be OK here since we're just getting the callback
assert(strm);
mQueryProcessor->presenceConnectedStream(ho, sporef, strm);
}
}
cb(sporef, after);
}
Result * Homography::applyInternal(Image *img)
{
Mat &m = img->getMat();
Mat ho(3, 3, CV_64F);
for (int i=0; i<9; i++)
ho.at<double>(i) = h[i];
warpPerspective(m, m, ho, m.size(), interpolation);
return new Result(toQTransform(ho));
}
// Finish processing of the transition to State::DEAD. Some things need to be done
// outside of holding |get_lock()|. Beware this is called from several places
// including on_zero_handles().
void ProcessDispatcher::FinishDeadTransition() {
DEBUG_ASSERT(!completely_dead_);
completely_dead_ = true;
// clean up the handle table
LTRACEF_LEVEL(2, "cleaning up handle table on proc %p\n", this);
fbl::DoublyLinkedList<Handle*> to_clean;
{
Guard<fbl::Mutex> guard{&handle_table_lock_};
for (auto& handle : handles_) {
handle.set_process_id(ZX_KOID_INVALID);
}
to_clean.swap(handles_);
}
// zx-1544: Here is where if we're the last holder of a handle of one of
// our exception ports then ResetExceptionPort will get called (by
// ExceptionPort::OnPortZeroHandles) and will need to grab |get_lock()|.
// This needs to be done outside of |get_lock()|.
while (!to_clean.is_empty()) {
// Delete handle via HandleOwner dtor.
HandleOwner ho(to_clean.pop_front());
}
LTRACEF_LEVEL(2, "done cleaning up handle table on proc %p\n", this);
// tear down the address space
aspace_->Destroy();
// signal waiter
LTRACEF_LEVEL(2, "signaling waiters\n");
UpdateState(0u, ZX_TASK_TERMINATED);
// The PROC_CREATE record currently emits a uint32_t koid.
uint32_t koid = static_cast<uint32_t>(get_koid());
ktrace(TAG_PROC_EXIT, koid, 0, 0, 0);
// Call job_->RemoveChildProcess(this) outside of |get_lock()|. Otherwise
// we risk a deadlock as we have |get_lock()| and RemoveChildProcess grabs
// the job's |lock_|, whereas JobDispatcher::EnumerateChildren obtains the
// locks in the opposite order. We want to keep lock acquisition order
// consistent, and JobDispatcher::EnumerateChildren's order makes
// sense. We don't need |get_lock()| when calling RemoveChildProcess
// here. ZX-880
// RemoveChildProcess is called soon after releasing |get_lock()| so that
// the semantics of signaling ZX_JOB_NO_PROCESSES match that of
// ZX_TASK_TERMINATED.
job_->RemoveChildProcess(this);
}
void ObjectHost::wrappedConnectedCallback(HostedObjectWPtr ho_weak, const SpaceID& space, const ObjectReference& obj, const SessionManager::ConnectionInfo& ci, ConnectedCallback cb) {
if (mQueryProcessor != NULL) {
HostedObjectPtr ho(ho_weak);
if (ho)
mQueryProcessor->presenceConnected(ho, SpaceObjectReference(space, obj));
}
ConnectionInfo info;
info.server = ci.server;
info.loc = ci.loc;
info.orient = ci.orient;
info.bnds = ci.bounds;
info.mesh = ci.mesh;
info.physics = ci.physics;
info.query = ci.query;
cb(space, obj, info);
}
