+

+    ok(

+      prompt.ui.button0.disabled,

+      "Accept button should be disabled by the security delay initially."

+    );

+

+    ok(

+      !prompt.ui.button1.disabled,

+      "Cancel button should not be disabled by the security delay."

+    );

+

+    info("Wait for the security delay to pass.");

+    let delayTime = Services.prefs.getIntPref("security.dialog_enable_delay");

+    // eslint-disable-next-line mozilla/no-arbitrary-setTimeout

+    await new Promise(resolve => setTimeout(resolve, delayTime + 100));

+

+    ok(

+      !prompt.ui.button0.disabled,

+      "Accept button should no longer be disabled."

+    );

+    ok(!prompt.ui.button1.disabled, "Cancel button should remain enabled.");

+        buttonFlags | Ci.nsIPrompt.BUTTON_DELAY_ENABLE,

+  if (const char* failure =

+          context->BrowsingContextCoherencyChecks(aOriginProcess)) {

+    mozilla::ipc::IProtocol* actor = aOriginProcess;

+    if (!actor) {

+      actor = ContentChild::GetSingleton();

+    }

+    return IPC_FAIL(actor, "Incoherent BrowsingContext");

+  }

+

+  context->Attach(/* aFromIPC */ true, aOriginProcess);

+  return IPC_OK();

+const char* BrowsingContext::BrowsingContextCoherencyChecks(

+    ContentParent* aOriginProcess) {

+#define COHERENCY_ASSERT(condition) \

+  if (!(condition)) return "Assertion " #condition " failed";

+

+  if (mGroup->IsPotentiallyCrossOriginIsolated() !=

+      (Top()->GetOpenerPolicy() ==

+       nsILoadInfo::OPENER_POLICY_SAME_ORIGIN_EMBEDDER_POLICY_REQUIRE_CORP)) {

+    return "Invalid CrossOriginIsolated state";

+  }

+

+  if (aOriginProcess && !IsContent()) {

+    return "Content cannot create chrome BCs";

+  }

+

+  // LoadContext should generally match our opener or parent.

+  if (IsContent()) {

+    if (RefPtr<BrowsingContext> opener = GetOpener()) {

+      COHERENCY_ASSERT(opener->mType == mType);

+      COHERENCY_ASSERT(opener->mGroup == mGroup);

+      COHERENCY_ASSERT(opener->mUseRemoteTabs == mUseRemoteTabs);

+      COHERENCY_ASSERT(opener->mUseRemoteSubframes == mUseRemoteSubframes);

+      COHERENCY_ASSERT(opener->mPrivateBrowsingId == mPrivateBrowsingId);

+      COHERENCY_ASSERT(

+          opener->mOriginAttributes.EqualsIgnoringFPD(mOriginAttributes));

+    }

+  }

+  if (RefPtr<BrowsingContext> parent = GetParent()) {

+    COHERENCY_ASSERT(parent->mType == mType);

+    COHERENCY_ASSERT(parent->mGroup == mGroup);

+    COHERENCY_ASSERT(parent->mUseRemoteTabs == mUseRemoteTabs);

+    COHERENCY_ASSERT(parent->mUseRemoteSubframes == mUseRemoteSubframes);

+    COHERENCY_ASSERT(parent->mPrivateBrowsingId == mPrivateBrowsingId);

+    COHERENCY_ASSERT(

+        parent->mOriginAttributes.EqualsIgnoringFPD(mOriginAttributes));

+  }

+

+  // UseRemoteSubframes and UseRemoteTabs must match.

+  if (mUseRemoteSubframes && !mUseRemoteTabs) {

+    return "Cannot set useRemoteSubframes without also setting useRemoteTabs";

+  }

+

+  // Double-check OriginAttributes/Private Browsing

+  // Chrome browsing contexts must not have a private browsing OriginAttribute

+  // Content browsing contexts must maintain the equality:

+  // mOriginAttributes.mPrivateBrowsingId == mPrivateBrowsingId

+  if (IsChrome()) {

+    COHERENCY_ASSERT(mOriginAttributes.mPrivateBrowsingId == 0);

+  } else {

+    COHERENCY_ASSERT(mOriginAttributes.mPrivateBrowsingId ==

+                     mPrivateBrowsingId);

+  }

+#undef COHERENCY_ASSERT

+

+  return nullptr;

+}

+

+void BrowsingContext::Attach(bool aFromIPC, ContentParent* aOriginProcess) {

+#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED

+  // We'll already have checked this if `aFromIPC` is set before calling this

+  // function.

+  if (!aFromIPC) {

+    if (const char* failure = BrowsingContextCoherencyChecks(aOriginProcess)) {

+      MOZ_CRASH_UNSAFE_PRINTF("Incoherent BrowsingContext: %s", failure);

+#endif

+  // Assert that this BrowsingContext is coherent relative to related

+  // BrowsingContexts. This will be run before the BrowsingContext is attached.

+  //

+  // A non-null string return value indicates that there was a coherency check

+  // failure, which will be handled with either a crash or IPC failure.

+  //

+  // If provided, `aOriginProcess` is the process which is responsible for the

+  // creation of this BrowsingContext.

+  [[nodiscard]] const char* BrowsingContextCoherencyChecks(

+      ContentParent* aOriginProcess);

+

+  void Attach(bool aFromIPC, ContentParent* aOriginProcess);

+    bool aIsTopFrame, bool aUseErrorPages,

+    // by the browser itself. Showing the error for page-triggered navigations

+    // causes annoying behavior for users, see bug 1528305.

+    if (!info->TriggeringPrincipal()->IsSystemPrincipal()) {

+      bool aIsTopFrame, bool aUseErrorPages,

+void Document::ImportRuleLoaded(StyleSheet& aSheet) {

+  void ImportRuleLoaded(StyleSheet&);

+void ShadowRoot::ImportRuleLoaded(StyleSheet& aSheet) {

+  void ImportRuleLoaded(StyleSheet&);

+function waitForButtonEnabledState(button) {

+  return new Promise(resolve => {

+    // Check if the button is already enabled (not disabled)

+    if (!button.disabled) {

+      resolve();

+      return;

+    }

+

+    // Create a MutationObserver instance

+    let win = button.ownerGlobal;

+    let { MutationObserver } = win;

+    const observer = new MutationObserver(mutationsList => {

+      for (const mutation of mutationsList) {

+        if (

+          mutation.type === "attributes" &&

+          mutation.attributeName === "disabled"

+        ) {

+          if (!button.disabled) {

+            // Resolve the promise when the button is enabled

+            observer.disconnect(); // Stop observing

+            resolve();

+          }

+        }

+      }

+    });

+

+    // Start observing the button for changes to the 'disabled' attribute

+    observer.observe(button, {

+      attributes: true,

+      attributeFilter: ["disabled"],

+    });

+  });

+}

+

+async function dialogObserver(subj) {

+  let dialog = subj.document.querySelector("dialog");

+  let acceptButton = dialog.getButton("accept");

+  await waitForButtonEnabledState(acceptButton);

+

+#define JS_SCERR_TRANSFERABLE_TWICE 9

+MSG_DEF(JSMSG_SC_TRANSFERABLE_TWICE,   0, JSEXN_TYPEERR, "structured clone cannot transfer twice")

+

+    try {

+        // This fails without logging anything, since the re-transfer will be caught

+        // by looking at its header before calling any callbacks.

+        let clone = deserialize(s);

+    } catch (e) {

+        assertEq(e.message.includes("cannot transfer twice"), true);

+    }

+

+        // 'F' means the data is freed.

+[[nodiscard]] static bool DepthFirstSearchUse(MIRGenerator* mir,

+                                              MPhiUseIteratorStack& worklist,

+                                              MPhi* phi) {

+[[nodiscard]] static bool FlagPhiInputsAsImplicitlyUsed(

+    MIRGenerator* mir, MBasicBlock* block, MBasicBlock* succ,

+    MPhiUseIteratorStack& worklist) {

+[[nodiscard]] static bool FlagOperandsAsImplicitlyUsedAfter(

+[[nodiscard]] static bool FlagEntryResumePointOperands(MIRGenerator* mir,

+                                                       MBasicBlock* block) {

+[[nodiscard]] static bool FlagAllOperandsAsImplicitlyUsed(MIRGenerator* mir,

+                                                          MBasicBlock* block) {

+      if (!FlagAllOperandsAsImplicitlyUsed(mir, block)) {

+        return false;

+      }

+      if (!FlagOperandsAsImplicitlyUsedAfter(mir, block, firstRemoved)) {

+        return false;

+      }

+[[nodiscard]] static bool SplitCriticalEdgesForBlock(MIRGraph& graph,

+                                                     MBasicBlock* block) {

+[[nodiscard]] static bool MaybeFoldDiamondConditionBlock(

+    MIRGraph& graph, MBasicBlock* initialBlock) {

+[[nodiscard]] static bool MaybeFoldTriangleConditionBlock(

+    MIRGraph& graph, MBasicBlock* initialBlock) {

+[[nodiscard]] static bool MaybeFoldConditionBlock(MIRGraph& graph,

+                                                  MBasicBlock* initialBlock) {

+[[nodiscard]] static bool MaybeFoldTestBlock(MIRGraph& graph,

+                                             MBasicBlock* initialBlock) {

+      if (!FlagAllOperandsAsImplicitlyUsed(mir, block)) {

+        return false;

+      }

+[[nodiscard]] static bool TryEliminateGCBarriersForAllocation(

+    TempAllocator& alloc, MInstruction* allocation) {

+ *   - <SCTAG_TRANSFER_MAP_HEADER, UNREAD|TRANSFERRING|TRANSFERRED>

+ *   - numTransferables (64 bits)

+ *   - array of:

+ *     - <SCTAG_TRANSFER_MAP_*, TransferableOwnership> pointer (64

+ *       bits)

+ *     - extraData (64 bits), eg byte length for ArrayBuffers

+ *     - any data written for custom transferables

+// contents have been read out yet or not. TRANSFERRING is for the case where we

+// have started but not completed reading, which due to errors could mean that

+// there are things still owned by the clone buffer that need to be released, so

+// discarding should not just be skipped.

+enum TransferableMapHeader {

+  SCTAG_TM_UNREAD = 0,

+  SCTAG_TM_TRANSFERRING,

+  SCTAG_TM_TRANSFERRED

+};

+    case JS_SCERR_TRANSFERABLE_TWICE:

+      errorNumber = JSMSG_SC_TRANSFERABLE_TWICE;

+      break;

+

+  auto transferState = static_cast<TransferableMapHeader>(data);

+

+      transferState == SCTAG_TM_TRANSFERRED) {

+  if (transferState == SCTAG_TM_TRANSFERRING) {

+    ReportDataCloneError(cx, callbacks, JS_SCERR_TRANSFERABLE_TWICE, closure);

+    return false;

+  }

+

+  headerPos.write(

+      PairToUInt64(SCTAG_TRANSFER_MAP_HEADER, SCTAG_TM_TRANSFERRING));

+

+  MOZ_ASSERT(TransferableMapHeader(data) == SCTAG_TM_TRANSFERRING);

+void ServoStyleSet::ImportRuleLoaded(StyleSheet& aSheet) {

+  void ImportRuleLoaded(StyleSheet&);

+  MOZ_DIAGNOSTIC_ASSERT(this == aSheet->GetParentSheet(),

+                        "We are being notified of a sheet load for a sheet "

+                        "that is not our child!");

+  // The assert below should hold if we stop triggering import loads for invalid

+  // insertRule() calls, see bug 1914106.

+  // MOZ_ASSERT(aSheet->GetOwnerRule());

+  if (!aSheet->GetOwnerRule()) {

+    return NS_OK;

+  }

+  NOTIFY(ImportRuleLoaded, (*aSheet));

+      loadingContext->GetUseErrorPages(), nullptr);

+    if (!mStopRequestCalled) {

+      CopyableTArray<uint8_t> copied(aData);

+      mPendingEvents.AppendElement(

+          [self = RefPtr{this}, data = std::move(copied)]() mutable {

+            self->OnDatagramReceivedInternal(std::move(data));

+          });

+      return NS_OK;

+    }

+

+<!doctype html>

+<link rel="help" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1914106">

+<style></style>

+<script>

+document.querySelector("style").sheet.insertRule("@import url('data:text/css,:root{background:red}');html,body{/* random garbage */}");

+</script>