Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-09 19:35:51 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1618547 - Support Fission in the process priority manager. r=kmag,gsvelto

Browse Source 
With Fission, there can be multiple BrowserParents in a single tab, so
this patch moves the tracking of active tabs onto the top BrowsingContext
in a tab. If the priority of a top BC is changed, then the activity
of all of the BPs of the BCs in the tree are all adjusted. The flag
that tracks this state gets carried forward to the new BC in the case
of a cross-group navigation by the changes in ReplacedBy().

The other change here covers the case where we do a process-switching
navigation on an iframe. If we create a new BrowserParent with an active
top BC, then the BP gets marked as active in the priority manager. Doing
this tracking on the BP instead of the BC (both here in and in the part
that landed previously in BrowserParent::Deactivated()) means that we
don't need to track down every place that a BC switches processes.

I left the tracking of activity in ParticularProcessPriorityManager
centered around BrowserParents, instead of changing it to BCs, to
minimize the changes required. There are some tricky interactions there
with wakelocks that I didn't want to have to figure out.

browser_ProcessPriorityManager.js was set up to track a mapping of
browsers to priorities, but for the purposes of testing Fission support
I changed it to track a mapping of child IDs to priorities.

In the test, I also removed an assignment (this.window = null) that
didn't seem to be doing anything.

Differential Revision: https://phabricator.services.mozilla.com/D112213
This commit is contained in:
Andrew McCreight 2021-05-05 20:29:14 +00:00
parent 429bd59056
commit 063f9001b0
11 changed files with 347 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
docshell/base/CanonicalBrowsingContext.cpp
View File

@ -223,6 +223,11 @@ void CanonicalBrowsingContext::ReplacedBy(
BackgroundSessionStorageManager::PropagateManager(Id(), aNewContext->Id());
}
// Transfer the ownership of the priority active status from the old context
// to the new context.
aNewContext->mPriorityActive = mPriorityActive;
mPriorityActive = false;
MOZ_ASSERT(aNewContext->mLoadingEntries.IsEmpty());
mLoadingEntries.SwapElements(aNewContext->mLoadingEntries);
MOZ_ASSERT(!aNewContext->mActiveEntry);

15
docshell/base/CanonicalBrowsingContext.h
View File

@ -302,6 +302,17 @@ class CanonicalBrowsingContext final : public BrowsingContext {
bool AllowedInBFCache(const Maybe<uint64_t>& aChannelId);
// Methods for getting and setting the active state for top level
// browsing contexts, for the process priority manager.
bool IsPriorityActive() const {
MOZ_RELEASE_ASSERT(IsTop());
return mPriorityActive;
}
void SetPriorityActive(bool aIsActive) {
MOZ_RELEASE_ASSERT(IsTop());
mPriorityActive = aIsActive;
}
protected:
// Called when the browsing context is being discarded.
void CanonicalDiscard();
@ -443,6 +454,10 @@ class CanonicalBrowsingContext final : public BrowsingContext {
RefPtr<FeaturePolicy> mContainerFeaturePolicy;
RefPtr<RestoreState> mRestoreState;
// If this is a top level context, this is true if our browser ID is marked as
// active in the process priority manager.
bool mPriorityActive = false;
};
} // namespace dom

7
dom/ipc/BrowserHost.cpp
View File

@ -10,6 +10,7 @@
#include "mozilla/dom/CancelContentJSOptionsBinding.h"
#include "mozilla/dom/ContentParent.h"
#include "mozilla/dom/WindowGlobalParent.h"
#include "mozilla/ProcessPriorityManager.h"
#include "nsIObserverService.h"
@ -116,6 +117,8 @@ BrowserHost::SetRenderLayers(bool aRenderLayers) {
if (!mRoot) {
return NS_OK;
}
ProcessPriorityManager::ActivityChanged(GetBrowsingContext()->Canonical(),
aRenderLayers);
mRoot->SetRenderLayers(aRenderLayers);
return NS_OK;
}
@ -149,8 +152,8 @@ BrowserHost::Deprioritize(void) {
if (!mRoot) {
return NS_OK;
}
VisitAll(
[](BrowserParent* aBrowserParent) { aBrowserParent->Deprioritize(); });
ProcessPriorityManager::ActivityChanged(GetBrowsingContext()->Canonical(),
/* aIsActive = */ false);
return NS_OK;
}

23
dom/ipc/BrowserParent.cpp
View File

@ -224,7 +224,6 @@ BrowserParent::BrowserParent(ContentParent* aManager, const TabId& aTabId,
mRemoteTargetSetsCursor(false),
mPreserveLayers(false),
mRenderLayers(true),
mActiveInPriorityManager(false),
mHasLayers(false),
mHasPresented(false),
mIsReadyToHandleInputEvents(false),
@ -234,6 +233,14 @@ BrowserParent::BrowserParent(ContentParent* aManager, const TabId& aTabId,
// When the input event queue is disabled, we don't need to handle the case
// that some input events are dispatched before PBrowserConstructor.
mIsReadyToHandleInputEvents = !ContentParent::IsInputEventQueueSupported();
// If we're in a BC tree that is active with respect to the priority manager,
// ensure that this new BrowserParent is marked as active. This ensures that
// the process will be prioritized in a cross-site iframe navigation in an
// active tab.
if (aBrowsingContext->Top()->IsPriorityActive()) {
ProcessPriorityManager::ActivityChanged(this, true);
}
}
BrowserParent::~BrowserParent() = default;
@ -3377,13 +3384,6 @@ bool BrowserParent::GetHasLayers() { return mHasLayers; }
bool BrowserParent::GetRenderLayers() { return mRenderLayers; }
void BrowserParent::SetRenderLayers(bool aEnabled) {
if (mActiveInPriorityManager != aEnabled) {
mActiveInPriorityManager = aEnabled;
// Let's inform the priority manager. This operation can end up with the
// changing of the process priority.
ProcessPriorityManager::ActivityChanged(this, aEnabled);
}
if (aEnabled == mRenderLayers) {
if (aEnabled && mHasLayers && mPreserveLayers) {
// RenderLayers might be called when we've been preserving layers,
@ -3446,13 +3446,6 @@ void BrowserParent::NotifyResolutionChanged() {
}
}
void BrowserParent::Deprioritize() {
if (mActiveInPriorityManager) {
ProcessPriorityManager::ActivityChanged(this, false);
mActiveInPriorityManager = false;
}
}
bool BrowserParent::StartApzAutoscroll(float aAnchorX, float aAnchorY,
nsViewID aScrollId,
uint32_t aPresShellId) {

5
dom/ipc/BrowserParent.h
View File

@ -702,8 +702,6 @@ class BrowserParent final : public PBrowserParent,
void PreserveLayers(bool aPreserveLayers);
void NotifyResolutionChanged();
void Deprioritize();
bool StartApzAutoscroll(float aAnchorX, float aAnchorY, nsViewID aScrollId,
uint32_t aPresShellId);
void StopApzAutoscroll(nsViewID aScrollId, uint32_t aPresShellId);
@ -969,9 +967,6 @@ class BrowserParent final : public PBrowserParent,
// and have uploaded - for that, use mHasLayers.
bool mRenderLayers : 1;
// Whether this is active for the ProcessPriorityManager or not.
bool mActiveInPriorityManager : 1;
// True if the compositor has reported that the BrowserChild has uploaded
// layers.
bool mHasLayers : 1;

35
dom/ipc/ProcessPriorityManager.cpp
View File

@ -6,6 +6,7 @@
#include "ProcessPriorityManager.h"
#include "mozilla/ClearOnShutdown.h"
#include "mozilla/dom/CanonicalBrowsingContext.h"
#include "mozilla/dom/ContentParent.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/BrowserHost.h"
@ -142,6 +143,7 @@ class ProcessPriorityManagerImpl final : public nsIObserver,
ParticularProcessPriorityManager* aParticularManager,
hal::ProcessPriority aOldPriority);
void ActivityChanged(CanonicalBrowsingContext* aBC, bool aIsActive);
void ActivityChanged(BrowserParent* aBrowserParent, bool aIsActive);
void ResetPriority(ContentParent* aContentParent);
@ -444,6 +446,31 @@ void ProcessPriorityManagerImpl::NotifyProcessPriorityChanged(
}
}
void ProcessPriorityManagerImpl::ActivityChanged(
dom::CanonicalBrowsingContext* aBC, bool aIsActive) {
MOZ_ASSERT(aBC->IsTop());
bool alreadyActive = aBC->IsPriorityActive();
if (alreadyActive == aIsActive) {
return;
}
Telemetry::ScalarAdd(
Telemetry::ScalarID::DOM_CONTENTPROCESS_OS_PRIORITY_CHANGE_CONSIDERED, 1);
aBC->SetPriorityActive(aIsActive);
aBC->PreOrderWalk([&](BrowsingContext* aContext) {
CanonicalBrowsingContext* canonical = aContext->Canonical();
if (ContentParent* cp = canonical->GetContentParent()) {
if (RefPtr<ParticularProcessPriorityManager> pppm =
GetParticularProcessPriorityManager(cp)) {
pppm->ActivityChanged(canonical->GetBrowserParent(), aIsActive);
}
}
});
}
void ProcessPriorityManagerImpl::ActivityChanged(BrowserParent* aBrowserParent,
bool aIsActive) {
RefPtr<ParticularProcessPriorityManager> pppm =
@ -857,6 +884,14 @@ bool ProcessPriorityManager::CurrentProcessIsForeground() {
return ProcessPriorityManagerChild::Singleton()->CurrentProcessIsForeground();
}
/* static */
void ProcessPriorityManager::ActivityChanged(CanonicalBrowsingContext* aBC,
bool aIsActive) {
if (auto* singleton = ProcessPriorityManagerImpl::GetSingleton()) {
singleton->ActivityChanged(aBC, aIsActive);
}
}
/* static */
void ProcessPriorityManager::ActivityChanged(BrowserParent* aBrowserParent,
bool aIsActive) {

3
dom/ipc/ProcessPriorityManager.h
View File

@ -14,6 +14,7 @@ class nsFrameLoader;
namespace mozilla {
namespace dom {
class BrowserParent;
class CanonicalBrowsingContext;
class ContentParent;
} // namespace dom
@ -70,6 +71,8 @@ class ProcessPriorityManager final {
*/
static bool CurrentProcessIsForeground();
static void ActivityChanged(dom::CanonicalBrowsingContext* aBC,
bool aIsActive);
static void ActivityChanged(dom::BrowserParent* aBrowserParent,
bool aIsActive);

5
dom/ipc/tests/browser.ini
View File

@ -11,6 +11,11 @@ skip-if = !crashreporter
apple_silicon # crash
[browser_ProcessPriorityManager.js]
skip-if = os != "win" # The Process Priority Manager is only enabled for Windows so far. Bug 1522879.
support-files =
file_cross_frame.html
file_dummy.html
../../tests/browser/file_coop_coep.html
../../tests/browser/file_coop_coep.html^headers^
[browser_crash_oopiframe.js]
skip-if = !fission || !crashreporter || verify
apple_silicon # crash

349
dom/ipc/tests/browser_ProcessPriorityManager.js
View File

@ -15,6 +15,11 @@ const PROCESS_PRIORITY_BACKGROUND = "BACKGROUND";
// change before we assume that it's just not happening.
const WAIT_FOR_CHANGE_TIME_MS = 2000;
// A convenience function for getting the child ID from a browsing context.
function browsingContextChildID(bc) {
return bc.currentWindowGlobal?.domProcess.childID;
}
/**
* This class is responsible for watching process priority changes, and
* mapping them to tabs in a single window.
@ -39,12 +44,14 @@ class TabPriorityWatcher {
"with a single tab to start."
);
this.priorityMap = new WeakMap();
this.priorityMap.set(
this.tabbrowser.selectedBrowser,
PROCESS_PRIORITY_FOREGROUND
);
this.noChangeBrowsers = new WeakMap();
// This maps from childIDs to process priorities.
this.priorityMap = new Map();
// The keys in this map are childIDs we're not expecting to change.
// Each value is either null (if no change has been seen) or the
// priority that the process changed to.
this.noChangeChildIDs = new Map();
Services.obs.addObserver(this, PRIORITY_SET_TOPIC);
}
@ -55,16 +62,15 @@ class TabPriorityWatcher {
*/
destroy() {
Services.obs.removeObserver(this, PRIORITY_SET_TOPIC);
this.window = null;
}
/**
* Returns a Promise that resolves when a particular <browser>
* has its content process reach a particular priority. Will
* eventually time out if that priority is never reached.
* This returns a Promise that resolves when the process with
* the given childID reaches the given priority.
* This will eventually time out if that priority is never reached.
*
* @param browser (<browser>)
* The <browser> that we expect to change priority.
* @param childID
* The childID of the process to wait on.
* @param expectedPriority (String)
* One of the PROCESS_PRIORITY_ constants defined at the
* top of this file.
@ -72,74 +78,91 @@ class TabPriorityWatcher {
* @resolves undefined
* Once the browser reaches the expected priority.
*/
async waitForPriorityChange(browser, expectedPriority) {
return TestUtils.waitForCondition(() => {
let currentPriority = this.priorityMap.get(browser);
async waitForPriorityChange(childID, expectedPriority) {
await TestUtils.waitForCondition(() => {
let currentPriority = this.priorityMap.get(childID);
if (currentPriority == expectedPriority) {
Assert.ok(
true,
`Browser at ${browser.currentURI.spec} reached expected ` +
`Process with child ID ${childID} reached expected ` +
`priority: ${currentPriority}`
);
return true;
}
return false;
}, `Waiting for browser at ${browser.currentURI.spec} to reach priority ` + expectedPriority);
}, `Waiting for process with child ID ${childID} to reach priority ${expectedPriority}`);
}
/**
* Returns a Promise that resolves after a duration of
* WAIT_FOR_CHANGE_TIME_MS. During that time, if the passed browser
* changes priority, a test failure will be registered.
* WAIT_FOR_CHANGE_TIME_MS. During that time, if the process
* with the passed in child ID changes priority, a test
* failure will be registered.
*
* @param browser (<browser>)
* The <browser> that we expect to change priority.
* @param childID
* The childID of the process that we expect to not change priority.
* @return Promise
* @resolves undefined
* Once the WAIT_FOR_CHANGE_TIME_MS duration has passed.
*/
async ensureNoPriorityChange(browser) {
this.noChangeBrowsers.set(browser, null);
async ensureNoPriorityChange(childID) {
this.noChangeChildIDs.set(childID, null);
// eslint-disable-next-line mozilla/no-arbitrary-setTimeout
await new Promise(resolve => setTimeout(resolve, WAIT_FOR_CHANGE_TIME_MS));
let priority = this.noChangeBrowsers.get(browser);
let priority = this.noChangeChildIDs.get(childID);
Assert.equal(
priority,
null,
`Should have seen no process priority change for a browser at ${browser.currentURI.spec}`
`Should have seen no process priority change for child ID ${childID}`
);
this.noChangeBrowsers.delete(browser);
this.noChangeChildIDs.delete(childID);
}
/**
* Makes sure that a particular foreground browser has been
* registered in the priority map. This is needed because browsers are
* only registered when their priorities change - and if a browser's
* priority never changes during a test, then they wouldn't be registered.
* This returns a Promise that resolves when all of the processes
* of the browsing contexts in the browsing context tree
* of a particular <browser> have reached a particular priority.
* This will eventually time out if that priority is never reached.
*
* The passed browser must be a foreground browser, since it's assumed that
* the associated content process is running with foreground priority.
*
* @param browser (browser)
* A _foreground_ browser.
* @param browser (<browser>)
* The <browser> to get the BC tree from.
* @param expectedPriority (String)
* One of the PROCESS_PRIORITY_ constants defined at the
* top of this file.
* @return Promise
* @resolves undefined
* Once the browser reaches the expected priority.
*/
ensureForegroundRegistered(browser) {
if (!this.priorityMap.has(browser)) {
this.priorityMap.set(browser, PROCESS_PRIORITY_FOREGROUND);
async waitForBrowserTreePriority(browser, expectedPriority) {
let childIDs = new Set(
browser.browsingContext
.getAllBrowsingContextsInSubtree()
.map(browsingContextChildID)
);
let promises = [];
for (let childID of childIDs) {
let currentPriority = this.priorityMap.get(childID);
promises.push(
currentPriority == expectedPriority
? this.ensureNoPriorityChange(childID)
: this.waitForPriorityChange(childID, expectedPriority)
);
}
await Promise.all(promises);
}
/**
* Synchronously returns the priority of a particular browser's
* content process.
* Synchronously returns the priority of a particular child ID.
*
* @param browser (browser)
* The browser to get the content process priority for.
* @param childID
* The childID to get the content process priority for.
* @return String
* The priority that the browser's content process is at.
* The priority of the child ID's process.
*/
currentPriority(browser) {
return this.priorityMap.get(browser);
currentPriority(childID) {
return this.priorityMap.get(childID);
}
/**
@ -175,17 +198,10 @@ class TabPriorityWatcher {
}
let { childID, priority } = this.parsePPMData(data);
for (let browser of this.tabbrowser.browsers) {
if (browser.frameLoader.childID == childID) {
info(
`Browser at: ${browser.currentURI.spec} transitioning to ${priority}`
);
if (this.noChangeBrowsers.has(browser)) {
this.noChangeBrowsers.set(browser, priority);
}
this.priorityMap.set(browser, priority);
}
if (this.noChangeChildIDs.has(childID)) {
this.noChangeChildIDs.set(childID, priority);
}
this.priorityMap.set(childID, priority);
}
}
@ -255,32 +271,14 @@ async function assertPriorityChangeOnBackground({
"Tabs should be running in separate processes."
);
gTabPriorityWatcher.ensureForegroundRegistered(fromBrowser);
let fromPromise;
if (
gTabPriorityWatcher.currentPriority(fromBrowser) == fromTabExpectedPriority
) {
fromPromise = gTabPriorityWatcher.ensureNoPriorityChange(fromBrowser);
} else {
fromPromise = gTabPriorityWatcher.waitForPriorityChange(
fromBrowser,
fromTabExpectedPriority
);
}
let toPromise;
if (
gTabPriorityWatcher.currentPriority(toBrowser) ==
let fromPromise = gTabPriorityWatcher.waitForBrowserTreePriority(
fromBrowser,
fromTabExpectedPriority
);
let toPromise = gTabPriorityWatcher.waitForBrowserTreePriority(
toBrowser,
PROCESS_PRIORITY_FOREGROUND
) {
toPromise = gTabPriorityWatcher.ensureNoPriorityChange(toBrowser);
} else {
toPromise = gTabPriorityWatcher.waitForPriorityChange(
toBrowser,
PROCESS_PRIORITY_FOREGROUND
);
}
);
await BrowserTestUtils.switchTab(gBrowser, toTab);
await Promise.all([fromPromise, toPromise]);
@ -294,20 +292,185 @@ async function assertPriorityChangeOnBackground({
add_task(async function test_normal_background_tab() {
let originalTab = gBrowser.selectedTab;
await BrowserTestUtils.withNewTab("http://example.com", async browser => {
let tab = gBrowser.getTabForBrowser(browser);
await assertPriorityChangeOnBackground({
fromTab: tab,
toTab: originalTab,
fromTabExpectedPriority: PROCESS_PRIORITY_BACKGROUND,
});
await BrowserTestUtils.withNewTab(
"http://example.com/browser/dom/ipc/tests/file_cross_frame.html",
async browser => {
let tab = gBrowser.getTabForBrowser(browser);
await assertPriorityChangeOnBackground({
fromTab: tab,
toTab: originalTab,
fromTabExpectedPriority: PROCESS_PRIORITY_BACKGROUND,
});
await assertPriorityChangeOnBackground({
fromTab: originalTab,
toTab: tab,
fromTabExpectedPriority: PROCESS_PRIORITY_BACKGROUND,
});
});
await assertPriorityChangeOnBackground({
fromTab: originalTab,
toTab: tab,
fromTabExpectedPriority: PROCESS_PRIORITY_BACKGROUND,
});
}
);
});
/**
* If an iframe in a foreground tab is navigated to a new page for
* a different site, then the process of the new iframe page should
* have priority PROCESS_PRIORITY_FOREGROUND. Additionally, if Fission
* is enabled, then the old iframe page's process's priority should be
* lowered to PROCESS_PRIORITY_BACKGROUND.
*/
add_task(async function test_iframe_navigate() {
// The URI we're going to navigate the iframe to.
let iframeURI2 =
"http://mochi.test:8888/browser/dom/ipc/tests/file_dummy.html";
// Load this as a top level tab so that when we later load it as an iframe we
// won't be creating a new process, so that we're testing the "load a new page"
// part of prioritization and not the "initial process load" part.
let newIFrameTab = await BrowserTestUtils.openNewForegroundTab(
gBrowser,
iframeURI2
);
let newIFrameTabChildID = browsingContextChildID(
gBrowser.selectedBrowser.browsingContext
);
Assert.equal(
gTabPriorityWatcher.currentPriority(newIFrameTabChildID),
PROCESS_PRIORITY_FOREGROUND,
"Loading a new tab should make it prioritized"
);
await BrowserTestUtils.withNewTab(
"http://example.com/browser/dom/ipc/tests/file_cross_frame.html",
async browser => {
Assert.equal(
gTabPriorityWatcher.currentPriority(newIFrameTabChildID),
PROCESS_PRIORITY_BACKGROUND,
"Switching to a new tab should deprioritize the old one"
);
let iframe = browser.browsingContext.children[0];
let iframeChildID1 = browsingContextChildID(iframe);
// Do a cross-origin navigation in the iframe in the foreground tab.
let loaded = BrowserTestUtils.browserLoaded(browser, true, iframeURI2);
await SpecialPowers.spawn(iframe, [iframeURI2], async function(
_iframeURI2
) {
content.location = _iframeURI2;
});
await loaded;
let iframeChildID2 = browsingContextChildID(iframe);
let iframePriority1 = gTabPriorityWatcher.currentPriority(iframeChildID1);
let iframePriority2 = gTabPriorityWatcher.currentPriority(iframeChildID2);
if (SpecialPowers.useRemoteSubframes) {
Assert.equal(
newIFrameTabChildID,
iframeChildID2,
"The same site should get loaded into the same process"
);
Assert.notEqual(
iframeChildID1,
iframeChildID2,
"Navigation should have switched processes"
);
Assert.equal(
iframePriority1,
PROCESS_PRIORITY_BACKGROUND,
"The old iframe process should have been deprioritized"
);
} else {
Assert.equal(
iframeChildID1,
iframeChildID2,
"Navigation should not have switched processes"
);
}
Assert.equal(
iframePriority2,
PROCESS_PRIORITY_FOREGROUND,
"The new iframe process should be prioritized"
);
}
);
await BrowserTestUtils.removeTab(newIFrameTab);
});
/**
* Test that a cross-group navigation properly preserves the process priority.
* The goal of this test is to check that the code related to mPriorityActive in
* CanonicalBrowsingContext::ReplacedBy works correctly, but in practice the
* prioritization code in SetRenderLayers will also make this test pass, though
* that prioritization happens slightly later.
*/
add_task(async function test_cross_group_navigate() {
// This page is same-site with the page we're going to cross-group navigate to.
let coopPage =
"https://example.com/browser/dom/tests/browser/file_coop_coep.html";
// Load it as a top level tab so that we don't accidentally get the initial
// load prioritization.
let backgroundTab = await BrowserTestUtils.openNewForegroundTab(
gBrowser,
coopPage
);
let backgroundTabChildID = browsingContextChildID(
gBrowser.selectedBrowser.browsingContext
);
Assert.equal(
gTabPriorityWatcher.currentPriority(backgroundTabChildID),
PROCESS_PRIORITY_FOREGROUND,
"Loading a new tab should make it prioritized"
);
await BrowserTestUtils.withNewTab(
"http://example.org/browser/dom/ipc/tests/file_cross_frame.html",
async browser => {
Assert.equal(
gTabPriorityWatcher.currentPriority(backgroundTabChildID),
PROCESS_PRIORITY_BACKGROUND,
"Switching to a new tab should deprioritize the old one"
);
let dotOrgChildID = browsingContextChildID(browser.browsingContext);
// Do a cross-group navigation.
BrowserTestUtils.loadURI(browser, coopPage);
await BrowserTestUtils.browserLoaded(browser);
let coopChildID = browsingContextChildID(browser.browsingContext);
let coopPriority = gTabPriorityWatcher.currentPriority(coopChildID);
let dotOrgPriority = gTabPriorityWatcher.currentPriority(dotOrgChildID);
Assert.equal(
backgroundTabChildID,
coopChildID,
"The same site should get loaded into the same process"
);
Assert.notEqual(
dotOrgChildID,
coopChildID,
"Navigation should have switched processes"
);
Assert.equal(
dotOrgPriority,
PROCESS_PRIORITY_BACKGROUND,
"The old page process should have been deprioritized"
);
Assert.equal(
coopPriority,
PROCESS_PRIORITY_FOREGROUND,
"The new page process should be prioritized"
);
}
);
await BrowserTestUtils.removeTab(backgroundTab);
});
/**

12
dom/ipc/tests/file_cross_frame.html Normal file
View File

@ -0,0 +1,12 @@
<!DOCTYPE HTML>
<html>
<head>
<meta charset="utf-8">
<title>Different-origin iframe</title>
</head>
<body>
<iframe id="testIFrame" src="http://example.org/browser/dom/ipc/tests/file_dummy.html"></iframe>
<i>I am a web page</i>
</div>
</body>
</html>

3
dom/ipc/tests/file_dummy.html
View File

@ -1,4 +1,7 @@
<!doctype html>
<html>
<head><meta charset="utf-8"></head>
<body>
<h1>This is a dummy file</h1>
</body>
</html>