FVector FGeomEdge::GetWidgetLocation()
{
FVector dir = (GetParentObject()->VertexPool[ VertexIndices[1] ] - GetParentObject()->VertexPool[ VertexIndices[0] ]);
const float dist = dir.Size() / 2;
dir.Normalize();
const FVector loc = GetParentObject()->VertexPool[ VertexIndices[0] ] + (dir * dist);
return GetParentObject()->GetActualBrush()->ActorToWorld().TransformPosition( loc );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectSapper::DetachObjectFromObject( void )
{
if ( GetParentObject() )
{
GetParentObject()->OnRemoveSapper();
}
BaseClass::DetachObjectFromObject();
}
FVector FGeomEdge::GetMidPoint() const
{
const FGeomVertex* wk0 = &(GetParentObject()->VertexPool[ VertexIndices[0] ]);
const FGeomVertex* wk1 = &(GetParentObject()->VertexPool[ VertexIndices[1] ]);
const FVector v0( wk0->X, wk0->Y, wk0->Z );
const FVector v1( wk1->X, wk1->Y, wk1->Z );
return (v0 + v1) / 2;
}
FileList*
DataTransfer::GetFiles(ErrorResult& aRv)
{
if (mEventType != NS_DRAGDROP_DROP && mEventType != NS_DRAGDROP_DRAGDROP &&
mEventType != NS_PASTE) {
return nullptr;
}
if (!mFiles) {
mFiles = new FileList(static_cast<nsIDOMDataTransfer*>(this));
uint32_t count = mItems.Length();
for (uint32_t i = 0; i < count; i++) {
nsCOMPtr<nsIVariant> variant;
aRv = MozGetDataAt(NS_ConvertUTF8toUTF16(kFileMime), i, getter_AddRefs(variant));
if (aRv.Failed()) {
return nullptr;
}
if (!variant)
continue;
nsCOMPtr<nsISupports> supports;
nsresult rv = variant->GetAsISupports(getter_AddRefs(supports));
if (NS_FAILED(rv))
continue;
nsCOMPtr<nsIFile> file = do_QueryInterface(supports);
nsRefPtr<File> domFile;
if (file) {
domFile = File::CreateFromFile(GetParentObject(), file);
} else {
nsCOMPtr<FileImpl> fileImpl = do_QueryInterface(supports);
if (!fileImpl) {
continue;
}
domFile = new File(GetParentObject(), static_cast<FileImpl*>(fileImpl.get()));
}
if (!mFiles->Append(domFile)) {
aRv.Throw(NS_ERROR_FAILURE);
return nullptr;
}
}
}
return mFiles;
}
//-----------------------------------------------------------------------------
// Purpose: Heal the object I'm attached to
//-----------------------------------------------------------------------------
void CObjectSelfHeal::SelfHealThink( void )
{
if ( !GetTeam() )
return;
CBaseObject *pObject = GetParentObject();
if ( !pObject )
{
Killed();
return;
}
SetNextThink( gpGlobals->curtime + obj_selfheal_rate.GetFloat(), SELFHEAL_THINK_CONTEXT );
// Don't heal if we've been EMPed
if ( HasPowerup( POWERUP_EMP ) )
return;
// Don't bring objects back from the dead
if ( !pObject->IsAlive() || pObject->IsDying() )
return;
// Repair our parent if it's hurt
pObject->Repair( obj_selfheal_amount.GetFloat() );
}
void C4ObjectMenu::LocalInit(C4Object *pObject, bool fUserMenu)
{
Object=pObject;
UserMenu=fUserMenu;
ParentObject=GetParentObject();
if (pObject) eCallbackType = CB_Object; else eCallbackType = CB_Scenario;
}
already_AddRefed<Promise>
MediaKeys::CreateSession(const nsAString& initDataType,
const Uint8Array& aInitData,
SessionType aSessionType,
ErrorResult& aRv)
{
aInitData.ComputeLengthAndData();
nsRefPtr<Promise> promise(MakePromise(aRv));
if (aRv.Failed()) {
return nullptr;
}
nsRefPtr<MediaKeySession> session = new MediaKeySession(GetParentObject(),
this,
mKeySystem,
aSessionType, aRv);
if (aRv.Failed()) {
return nullptr;
}
auto pid = StorePromise(promise);
// Hang onto session until the CDM has finished setting it up.
mPendingSessions.Put(pid, session);
mProxy->CreateSession(aSessionType,
pid,
initDataType,
aInitData);
return promise.forget();
}
nsresult
IDBRequest::NotifyHelperCompleted(HelperBase* aHelper)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
NS_ASSERTION(!mHaveResultOrErrorCode, "Already called!");
NS_ASSERTION(JSVAL_IS_VOID(mResultVal), "Should be undefined!");
// See if our window is still valid. If not then we're going to pretend that
// we never completed.
if (NS_FAILED(CheckInnerWindowCorrectness())) {
return NS_OK;
}
mHaveResultOrErrorCode = true;
nsresult rv = aHelper->GetResultCode();
// If the request failed then set the error code and return.
if (NS_FAILED(rv)) {
SetError(rv);
return NS_OK;
}
// Otherwise we need to get the result from the helper.
JSContext* cx = GetJSContext();
if (!cx) {
NS_WARNING("Failed to get safe JSContext!");
rv = NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
SetError(rv);
return rv;
}
JSObject* global = GetParentObject();
NS_ASSERTION(global, "This should never be null!");
JSAutoRequest ar(cx);
JSAutoEnterCompartment ac;
if (ac.enter(cx, global)) {
AssertIsRooted();
rv = aHelper->GetSuccessResult(cx, &mResultVal);
if (NS_FAILED(rv)) {
NS_WARNING("GetSuccessResult failed!");
}
}
else {
NS_WARNING("Failed to enter correct compartment!");
rv = NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
if (NS_SUCCEEDED(rv)) {
mError = nullptr;
}
else {
SetError(rv);
mResultVal = JSVAL_VOID;
}
return rv;
}
already_AddRefed<Promise> MediaDevices::GetDisplayMedia(
const DisplayMediaStreamConstraints& aConstraints, CallerType aCallerType,
ErrorResult& aRv) {
RefPtr<Promise> p = Promise::Create(GetParentObject(), aRv);
if (NS_WARN_IF(aRv.Failed())) {
return nullptr;
}
RefPtr<MediaDevices> self(this);
MediaManager::Get()
->GetDisplayMedia(GetOwner(), aConstraints, aCallerType)
->Then(GetCurrentThreadSerialEventTarget(), __func__,
[this, self, p](RefPtr<DOMMediaStream>&& aStream) {
if (!GetWindowIfCurrent()) {
return; // leave promise pending after navigation.
}
p->MaybeResolve(std::move(aStream));
},
[this, self, p](RefPtr<MediaMgrError>&& error) {
nsPIDOMWindowInner* window = GetWindowIfCurrent();
if (!window) {
return; // leave promise pending after navigation.
}
p->MaybeReject(MakeRefPtr<MediaStreamError>(window, *error));
});
return p.forget();
}
void
WrapperPromiseCallback::Call(const Optional<JS::Handle<JS::Value> >& aValue)
{
AutoJSContext cx;
Maybe<JSAutoCompartment> ac;
EnterCompartment(ac, cx, aValue);
ErrorResult rv;
// If invoking callback threw an exception, run resolver's reject with the
// thrown exception as argument and the synchronous flag set.
Optional<JS::Handle<JS::Value> > value(cx,
mCallback->Call(mNextResolver->GetParentObject(), aValue, rv,
CallbackObject::eRethrowExceptions));
rv.WouldReportJSException();
if (rv.Failed() && rv.IsJSException()) {
Optional<JS::Handle<JS::Value> > value(cx);
rv.StealJSException(cx, &value.Value());
Maybe<JSAutoCompartment> ac2;
EnterCompartment(ac2, cx, value);
mNextResolver->RejectInternal(cx, value, PromiseResolver::SyncTask);
return;
}
// Otherwise, run resolver's resolve with value and the synchronous flag
// set.
Maybe<JSAutoCompartment> ac2;
EnterCompartment(ac2, cx, value);
mNextResolver->ResolveInternal(cx, value, PromiseResolver::SyncTask);
}
already_AddRefed<Promise>
AudioContext::Close(ErrorResult& aRv)
{
nsCOMPtr<nsIGlobalObject> parentObject = do_QueryInterface(GetParentObject());
nsRefPtr<Promise> promise;
promise = Promise::Create(parentObject, aRv);
if (aRv.Failed()) {
return nullptr;
}
if (mIsOffline) {
promise->MaybeReject(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
return promise.forget();
}
if (mAudioContextState == AudioContextState::Closed) {
promise->MaybeResolve(NS_ERROR_DOM_INVALID_STATE_ERR);
return promise.forget();
}
mCloseCalled = true;
mPromiseGripArray.AppendElement(promise);
Graph()->ApplyAudioContextOperation(DestinationStream()->AsAudioNodeStream(),
AudioContextOperation::Close, promise);
MediaStream* ds = DestinationStream();
if (ds) {
ds->BlockStreamIfNeeded();
}
return promise.forget();
}
void
WrapperPromiseCallback::Call(const Optional<JS::Handle<JS::Value> >& aValue)
{
AutoJSContext cx;
// FIXME Bug 878849
Maybe<JSAutoCompartment> ac;
if (aValue.WasPassed() && aValue.Value().isObject()) {
JS::Rooted<JSObject*> rooted(cx, &aValue.Value().toObject());
ac.construct(cx, rooted);
}
ErrorResult rv;
// If invoking callback threw an exception, run resolver's reject with the
// thrown exception as argument and the synchronous flag set.
Optional<JS::Handle<JS::Value> > value(cx,
mCallback->Call(mNextResolver->GetParentObject(), aValue, rv,
CallbackObject::eRethrowExceptions));
rv.WouldReportJSException();
if (rv.Failed() && rv.IsJSException()) {
Optional<JS::Handle<JS::Value> > value(cx);
rv.StealJSException(cx, &value.Value());
mNextResolver->RejectInternal(cx, value, PromiseResolver::SyncTask);
return;
}
// Otherwise, run resolver's resolve with value and the synchronous flag
// set.
mNextResolver->ResolveInternal(cx, value, PromiseResolver::SyncTask);
}
pgCollection *ctlTree::GetParentCollection(wxTreeItemId id)
{
pgCollection *coll = (pgCollection *)GetParentObject(id);
if (coll && coll->IsCollection())
return coll;
return 0;
}
already_AddRefed<MediaKeySession>
MediaKeys::CreateSession(JSContext* aCx,
SessionType aSessionType,
ErrorResult& aRv)
{
if (!mProxy) {
NS_WARNING("Tried to use a MediaKeys which lost its CDM");
aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return nullptr;
}
EME_LOG("MediaKeys[%p] Creating session", this);
RefPtr<MediaKeySession> session = new MediaKeySession(aCx,
GetParentObject(),
this,
mKeySystem,
mCDMVersion,
aSessionType,
aRv);
if (aRv.Failed()) {
return nullptr;
}
// Add session to the set of sessions awaiting their sessionId being ready.
mPendingSessions.Put(session->Token(), session);
return session.forget();
}
already_AddRefed<Promise>
MediaKeys::LoadSession(const nsAString& aSessionId, ErrorResult& aRv)
{
nsRefPtr<Promise> promise(MakePromise(aRv));
if (aRv.Failed()) {
return nullptr;
}
if (aSessionId.IsEmpty()) {
promise->MaybeReject(NS_ERROR_DOM_INVALID_ACCESS_ERR);
// "The sessionId parameter is empty."
return promise.forget();
}
// TODO: The spec doesn't specify what to do in this case...
if (mKeySessions.Contains(aSessionId)) {
promise->MaybeReject(NS_ERROR_DOM_INVALID_ACCESS_ERR);
return promise.forget();
}
// Create session.
nsRefPtr<MediaKeySession> session(
new MediaKeySession(GetParentObject(), this, mKeySystem, SessionType::Persistent, aRv));
if (aRv.Failed()) {
return nullptr;
}
session->Init(aSessionId);
auto pid = StorePromise(promise);
mPendingSessions.Put(pid, session);
mProxy->LoadSession(pid, aSessionId);
return promise.forget();
}
already_AddRefed<Promise>
AudioContext::Resume(ErrorResult& aRv)
{
nsCOMPtr<nsIGlobalObject> parentObject = do_QueryInterface(GetParentObject());
nsRefPtr<Promise> promise;
promise = Promise::Create(parentObject, aRv);
if (aRv.Failed()) {
return nullptr;
}
if (mIsOffline) {
promise->MaybeReject(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
return promise.forget();
}
if (mAudioContextState == AudioContextState::Closed ||
mCloseCalled) {
promise->MaybeReject(NS_ERROR_DOM_INVALID_STATE_ERR);
return promise.forget();
}
if (mAudioContextState == AudioContextState::Running) {
promise->MaybeResolve(JS::UndefinedHandleValue);
return promise.forget();
}
Destination()->Resume();
mPromiseGripArray.AppendElement(promise);
Graph()->ApplyAudioContextOperation(DestinationStream()->AsAudioNodeStream(),
AudioContextOperation::Resume, promise);
return promise.forget();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseTFVehicle::FinishedBuilding( void )
{
BaseClass::FinishedBuilding();
// See if we've finished building on a vehicle that has a passenger slot assigned to my buildpoint.
CBaseObject *pParent = GetParentObject();
if ( pParent && pParent->IsAVehicle() )
{
CBaseTFVehicle *pVehicle = static_cast<CBaseTFVehicle*>(pParent);
int iRole = pVehicle->GetChildVehicleRole( this );
if ( iRole != -1 )
{
// Is there a player in the role assigned to this buildpoint?
CBaseTFPlayer *pExistingPlayer = static_cast<CBaseTFPlayer*>( pVehicle->GetPassenger( iRole ) );
if ( pExistingPlayer )
{
// Remove the player from my parent vehicle and put them in me
pExistingPlayer->LeaveVehicle();
// Get in the vehicle.
pExistingPlayer->GetInVehicle( this, VEHICLE_DRIVER );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseObjectDriverGun::ShouldPredict( void )
{
CBaseTFVehicle *pVehicle = dynamic_cast<CBaseTFVehicle*>(GetParentObject());
if ( pVehicle && pVehicle->GetDriverPlayer() == C_BasePlayer::GetLocalPlayer() )
return true;
return BaseClass::ShouldPredict();
}
FVector FGeomPoly::GetMidPoint() const
{
FVector Wk(0,0,0);
int32 Count = 0;
for( int32 e = 0 ; e < EdgeIndices.Num() ; ++e )
{
const FGeomEdge* ge = &GetParentObject()->EdgePool[ EdgeIndices[e] ];
Wk += GetParentObject()->VertexPool[ ge->VertexIndices[0] ];
Count++;
Wk += GetParentObject()->VertexPool[ ge->VertexIndices[1] ];
Count++;
}
check( Count );
return Wk / Count;
}
nsCOMPtr<nsIGlobalObject> OffscreenCanvas::GetGlobalObject() {
if (NS_IsMainThread()) {
return GetParentObject();
}
dom::WorkerPrivate* workerPrivate = dom::GetCurrentThreadWorkerPrivate();
return workerPrivate->GlobalScope();
}
void FileSystemFileEntry::GetFile(
FileCallback& aSuccessCallback,
const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback) const {
RefPtr<FileCallbackRunnable> runnable =
new FileCallbackRunnable(&aSuccessCallback, mFile);
FileSystemUtils::DispatchRunnable(GetParentObject(), runnable.forget());
}
already_AddRefed<TouchList> TouchEvent::CopyTouches(
const Sequence<OwningNonNull<Touch>>& aTouches) {
RefPtr<TouchList> list = new TouchList(GetParentObject());
size_t len = aTouches.Length();
for (size_t i = 0; i < len; ++i) {
list->Append(aTouches[i]);
}
return list.forget();
}
FPoly* FGeomPoly::GetActualPoly()
{
FGeomObject* Parent = GetParentObject();
check( Parent );
ABrush* Brush = Parent->GetActualBrush();
check( Brush );
return &( Brush->Brush->Polys->Element[ActualPolyIndex] );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectSapper::FinishedBuilding( void )
{
BaseClass::FinishedBuilding();
if ( GetParentObject() )
{
GetParentObject()->OnAddSapper();
}
EmitSound( "Weapon_Sapper.Plant" );
// start looping "Weapon_Sapper.Timer", killed when we die
EmitSound( "Weapon_Sapper.Timer" );
m_flSapperDamageAccumulator = 0;
m_flLastThinkTime = gpGlobals->curtime;
SetContextThink( &CObjectSapper::SapperThink, gpGlobals->curtime + 0.1, SAPPER_THINK_CONTEXT );
}
void
FileReader::OnLoadEndArrayBuffer()
{
AutoJSAPI jsapi;
if (!jsapi.Init(GetParentObject())) {
FreeDataAndDispatchError(NS_ERROR_FAILURE);
return;
}
RootResultArrayBuffer();
JSContext* cx = jsapi.cx();
mResultArrayBuffer = JS_NewArrayBufferWithContents(cx, mDataLen, mFileData);
if (mResultArrayBuffer) {
mFileData = nullptr; // Transfer ownership
FreeDataAndDispatchSuccess();
return;
}
// Let's handle the error status.
JS::Rooted<JS::Value> exceptionValue(cx);
if (!JS_GetPendingException(cx, &exceptionValue) ||
// This should not really happen, exception should always be an object.
!exceptionValue.isObject()) {
JS_ClearPendingException(jsapi.cx());
FreeDataAndDispatchError(NS_ERROR_OUT_OF_MEMORY);
return;
}
JS_ClearPendingException(jsapi.cx());
JS::Rooted<JSObject*> exceptionObject(cx, &exceptionValue.toObject());
JSErrorReport* er = JS_ErrorFromException(cx, exceptionObject);
if (!er || er->message()) {
FreeDataAndDispatchError(NS_ERROR_OUT_OF_MEMORY);
return;
}
nsAutoString errorName;
JSFlatString* name = js::GetErrorTypeName(cx, er->exnType);
if (name) {
AssignJSFlatString(errorName, name);
}
nsAutoCString errorMsg(er->message().c_str());
nsAutoCString errorNameC = NS_LossyConvertUTF16toASCII(errorName);
// XXX Code selected arbitrarily
mError =
new DOMException(NS_ERROR_DOM_INVALID_STATE_ERR, errorMsg,
errorNameC, DOMException_Binding::INVALID_STATE_ERR);
FreeDataAndDispatchError();
}
already_AddRefed<Promise>
MediaKeys::MakePromise(ErrorResult& aRv)
{
nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetParentObject());
if (!global) {
NS_WARNING("Passed non-global to MediaKeys ctor!");
aRv.Throw(NS_ERROR_UNEXPECTED);
return nullptr;
}
return Promise::Create(global, aRv);
}
already_AddRefed<Promise>
AudioContext::DecodeAudioData(const ArrayBuffer& aBuffer,
const Optional<OwningNonNull<DecodeSuccessCallback> >& aSuccessCallback,
const Optional<OwningNonNull<DecodeErrorCallback> >& aFailureCallback,
ErrorResult& aRv)
{
nsCOMPtr<nsIGlobalObject> parentObject = do_QueryInterface(GetParentObject());
RefPtr<Promise> promise;
AutoJSAPI jsapi;
jsapi.Init();
JSContext* cx = jsapi.cx();
JSAutoCompartment ac(cx, aBuffer.Obj());
promise = Promise::Create(parentObject, aRv);
if (aRv.Failed()) {
return nullptr;
}
aBuffer.ComputeLengthAndData();
if (aBuffer.IsShared()) {
// Throw if the object is mapping shared memory (must opt in).
aRv.ThrowTypeError<MSG_TYPEDARRAY_IS_SHARED>(NS_LITERAL_STRING("Argument of AudioContext.decodeAudioData"));
return nullptr;
}
// Detach the array buffer
size_t length = aBuffer.Length();
JS::RootedObject obj(cx, aBuffer.Obj());
uint8_t* data = static_cast<uint8_t*>(JS_StealArrayBufferContents(cx, obj));
// Sniff the content of the media.
// Failed type sniffing will be handled by AsyncDecodeWebAudio.
nsAutoCString contentType;
NS_SniffContent(NS_DATA_SNIFFER_CATEGORY, nullptr, data, length, contentType);
RefPtr<DecodeErrorCallback> failureCallback;
RefPtr<DecodeSuccessCallback> successCallback;
if (aFailureCallback.WasPassed()) {
failureCallback = &aFailureCallback.Value();
}
if (aSuccessCallback.WasPassed()) {
successCallback = &aSuccessCallback.Value();
}
RefPtr<WebAudioDecodeJob> job(
new WebAudioDecodeJob(contentType, this,
promise, successCallback, failureCallback));
AsyncDecodeWebAudio(contentType.get(), data, length, *job);
// Transfer the ownership to mDecodeJobs
mDecodeJobs.AppendElement(job.forget());
return promise.forget();
}
JSObject*
AudioContext::GetGlobalJSObject() const
{
nsCOMPtr<nsIGlobalObject> parentObject = do_QueryInterface(GetParentObject());
if (!parentObject) {
return nullptr;
}
// This can also return null.
return parentObject->GetGlobalJSObject();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseObjectDriverGun::FinishedBuilding( void )
{
#if !defined( CLIENT_DLL )
BaseClass::FinishedBuilding();
CBaseTFVehicle *pVehicle = dynamic_cast<CBaseTFVehicle*>(GetParentObject());
Assert( pVehicle );
pVehicle->SetDriverGun( this );
#endif
}
already_AddRefed<DetailedPromise>
MediaKeySession::MakePromise(ErrorResult& aRv, const nsACString& aName)
{
nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetParentObject());
if (!global) {
NS_WARNING("Passed non-global to MediaKeys ctor!");
aRv.Throw(NS_ERROR_UNEXPECTED);
return nullptr;
}
return DetailedPromise::Create(global, aRv, aName);
}
