void BrowsingContext::Blur(ErrorResult& aError) {
if (ContentChild* cc = ContentChild::GetSingleton()) {
cc->SendWindowBlur(this);
} else if (ContentParent* cp = Canonical()->GetContentParent()) {
Unused << cp->SendWindowBlur(this);
}
}
void BrowsingContext::PostMessageMoz(JSContext* aCx,
JS::Handle<JS::Value> aMessage,
const nsAString& aTargetOrigin,
const Sequence<JSObject*>& aTransfer,
nsIPrincipal& aSubjectPrincipal,
ErrorResult& aError) {
RefPtr<BrowsingContext> sourceBc;
PostMessageData data;
data.targetOrigin() = aTargetOrigin;
data.subjectPrincipal() = &aSubjectPrincipal;
RefPtr<nsGlobalWindowInner> callerInnerWindow;
if (!nsGlobalWindowOuter::GatherPostMessageData(
aCx, aTargetOrigin, getter_AddRefs(sourceBc), data.origin(),
getter_AddRefs(data.targetOriginURI()),
getter_AddRefs(data.callerPrincipal()),
getter_AddRefs(callerInnerWindow),
getter_AddRefs(data.callerDocumentURI()), aError)) {
return;
}
data.source() = sourceBc;
data.isFromPrivateWindow() =
callerInnerWindow &&
nsScriptErrorBase::ComputeIsFromPrivateWindow(callerInnerWindow);
JS::Rooted<JS::Value> transferArray(aCx);
aError = nsContentUtils::CreateJSValueFromSequenceOfObject(aCx, aTransfer,
&transferArray);
if (NS_WARN_IF(aError.Failed())) {
return;
}
ipc::StructuredCloneData message;
message.Write(aCx, aMessage, transferArray, aError);
if (NS_WARN_IF(aError.Failed())) {
return;
}
ClonedMessageData messageData;
if (ContentChild* cc = ContentChild::GetSingleton()) {
if (!message.BuildClonedMessageDataForChild(cc, messageData)) {
aError.Throw(NS_ERROR_FAILURE);
return;
}
cc->SendWindowPostMessage(this, messageData, data);
} else if (ContentParent* cp = Canonical()->GetContentParent()) {
if (!message.BuildClonedMessageDataForParent(cp, messageData)) {
aError.Throw(NS_ERROR_FAILURE);
return;
}
Unused << cp->SendWindowPostMessage(this, messageData, data);
}
}
void BrowsingContext::Close(CallerType aCallerType, ErrorResult& aError) {
// FIXME We need to set mClosed, but only once we're sending the
// DOMWindowClose event (which happens in the process where the
// document for this browsing context is loaded).
// See https://bugzilla.mozilla.org/show_bug.cgi?id=1516343.
if (ContentChild* cc = ContentChild::GetSingleton()) {
cc->SendWindowClose(this, aCallerType == CallerType::System);
} else if (ContentParent* cp = Canonical()->GetContentParent()) {
Unused << cp->SendWindowClose(this, aCallerType == CallerType::System);
}
}
Node *
cached(Node *n)
{ Cache *d;
Node *m;
if (!n) return n;
if ((m = in_cache(n)) != ZN)
return m;
Caches++;
d = (Cache *) tl_emalloc(sizeof(Cache));
d->before = dupnode(n);
d->after = Canonical(n); /* n is released */
if (ismatch(d->before, d->after))
{ d->same = 1;
releasenode(1, d->after);
d->after = d->before;
}
d->nxt = stored;
stored = d;
return dupnode(d->after);
}
void ATrap::DoCall (uint16 trapWord)
{
// Stop all profiling activities. Stop cycle counting and stop the
// recording of function entries and exits. We want our calls to
// ROM functions to be as transparent as possible.
StDisableAllProfiling stopper;
// Assert that the function we're trying to call is implemented.
//
// Oops...bad test...this doesn't work when we're calling a library.
// Instead, since we now invoke ROM functions by creating a TRAP $F
// sequence, we'll let our TRAP $F handler deal with validating the
// function call (it does that anyway).
// EmAssert (LowMem::GetTrapAddress (trapWord));
// We call the ROM function by dummying up a sequence of 68xxx instructions
// for it. The sequence of instructions is:
//
// TRAP $F
// DC.W <dispatch number>
// TRAP $C
//
// The first two words invoke the function (calling any head- or tailpatches
// along the way). The third word allows the emulator to regain control
// after the function has returned.
//
// Note: this gets a little ugly on little-endian machines. The following
// instructions are stored on the emulator's stack. This memory is mapped
// into the emulated address space in such a fashion that no byteswapping of
// word or long values occurs. Thus, we have to put the data into Big Endian
// format when putting it into the array.
//
// However, opcodes are a special case. They are optimized in the emulator
// for fast access. Opcodes are *always* fetched a word at a time in host-
// endian order. Thus, the opcodes below have to be stored in host-endian
// order. That's why there's no call to Canonical to put them into Big
// Endian order.
uint16 code[] = { kOpcode_ROMCall, trapWord, kOpcode_ATrapReturn };
// Oh, OK, we do have to byteswap the trapWord. Opcodes are fetched with
// EmMemDoGet16, which always gets the value in host byte order. The
// trapWord is fetched with EmMemGet16, which gets values according to the
// rules of the memory bank. For the dummy bank, the defined byte order
// is Big Endian.
Canonical (code[1]);
// Map in the code stub so that the emulation code can access it.
StMemoryMapper mapper (code, sizeof (code));
// Prepare to handle the TRAP 12 exception.
EmAssert (gCPU68K);
gCPU68K->InstallHookException (kException_ATrapReturn, PrvHandleTrap12);
// Point the PC to our code.
emuptr newPC = EmBankMapped::GetEmulatedAddress (code);
m68k_setpc (newPC);
// Execute until the next break.
try
{
EmAssert (gSession);
gSession->ExecuteSubroutine ();
}
catch (EmExceptionReset& e)
{
e.SetTrapWord (trapWord);
// Remove the TRAP 12 exception handler.
EmAssert (gCPU68K);
gCPU68K->RemoveHookException (kException_ATrapReturn, PrvHandleTrap12);
throw;
}
// Remove the TRAP 12 exception handler.
EmAssert (gCPU68K);
gCPU68K->RemoveHookException (kException_ATrapReturn, PrvHandleTrap12);
}