mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Merge mozilla-central to autoland

This commit is contained in:
Carsten "Tomcat" Book 2017-06-13 12:14:05 +02:00
Родитель 372ce9ac15 d67ef71097
Коммит 0aaf610c0f
239 изменённых файлов: 3136 добавлений и 1495 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

1
accessible/moz.build
Просмотреть файл

@ -33,6 +33,7 @@ TEST_DIRS += ['tests/mochitest']
BROWSER_CHROME_MANIFESTS += [
'tests/browser/browser.ini',
'tests/browser/e10s/browser.ini',
'tests/browser/scroll/browser.ini',
'tests/browser/states/browser.ini'
]

3
accessible/tests/browser/e10s/browser_caching_name.js
Просмотреть файл

@ -239,7 +239,8 @@ const markupTests = [{
</td>
</tr>
</table>`,
expected: ['test2 test3', 'test1', 'This is a paragraph',
expected: ['test2 test3', 'test1',
'This is a paragraph This is a link \u2022 Listitem1 \u2022 Listitem2',
'This is a paragraph This is a link This is a list']
}, {
id: 't',

10
accessible/tests/browser/scroll/browser.ini Normal file
Просмотреть файл

@ -0,0 +1,10 @@
[DEFAULT]
skip-if = e10s && os == 'win' && release_or_beta
support-files =
head.js
!/accessible/tests/browser/events.js
!/accessible/tests/browser/shared-head.js
!/accessible/tests/mochitest/*.js
[browser_test_zoom_text.js]
skip-if = e10s && os == 'win' # bug 1372296

119
accessible/tests/browser/scroll/browser_test_zoom_text.js Normal file
Просмотреть файл

@ -0,0 +1,119 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
'use strict';
/* import-globals-from ../../mochitest/layout.js */
loadScripts({ name: 'layout.js', dir: MOCHITESTS_DIR });
async function runTests(browser, accDoc) {
let paragraph = findAccessibleChildByID(accDoc, "paragraph", [nsIAccessibleText]);
let offset = 64; // beginning of 4th stanza
let [x /*,y*/] = getPos(paragraph);
let [docX, docY] = getPos(accDoc);
paragraph.scrollSubstringToPoint(offset, offset,
COORDTYPE_SCREEN_RELATIVE, docX, docY);
testTextPos(paragraph, offset, [x, docY], COORDTYPE_SCREEN_RELATIVE);
await zoomContent(browser, 2.0);
paragraph = findAccessibleChildByID(accDoc, "paragraph2", [nsIAccessibleText]);
offset = 52; // // beginning of 4th stanza
[x /*,y*/] = getPos(paragraph);
paragraph.scrollSubstringToPoint(offset, offset,
COORDTYPE_SCREEN_RELATIVE, docX, docY);
testTextPos(paragraph, offset, [x, docY], COORDTYPE_SCREEN_RELATIVE);
}
/**
* Test caching of accessible object states
*/
addAccessibleTask(`
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br><hr>
<p id='paragraph'>
Пошел котик на торжок<br>
Купил котик пирожок<br>
Пошел котик на улочку<br>
Купил котик булочку<br>
</p>
<hr><br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br><hr>
<p id='paragraph2'>
Самому ли съесть<br>
Либо Сашеньке снесть<br>
Я и сам укушу<br>
Я и Сашеньке снесу<br>
</p>
<hr><br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>
<br><br><br><br><br><br><br><br><br><br>`,
runTests
);

30
accessible/tests/browser/scroll/head.js Normal file
Просмотреть файл

@ -0,0 +1,30 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
'use strict';
/* exported zoomContent */
// Load the shared-head file first.
/* import-globals-from ../shared-head.js */
Services.scriptloader.loadSubScript(
'chrome://mochitests/content/browser/accessible/tests/browser/shared-head.js',
this);
async function zoomContent(browser, zoom)
{
return ContentTask.spawn(browser, zoom, _zoom => {
let docShell = content
.QueryInterface(Components.interfaces.nsIInterfaceRequestor)
.getInterface(Components.interfaces.nsIWebNavigation)
.QueryInterface(Components.interfaces.nsIDocShell);
let docViewer = docShell.contentViewer;
docViewer.fullZoom = _zoom;
});
}
// Loading and common.js from accessible/tests/mochitest/ for all tests, as
// well as events.js.
loadScripts({ name: 'common.js', dir: MOCHITESTS_DIR }, 'events.js');

31
accessible/tests/browser/shared-head.js
Просмотреть файл

@ -208,14 +208,15 @@ function addAccessibleTask(doc, task) {
url = `${CURRENT_CONTENT_DIR}e10s/${doc}`;
} else {
// Assume it's a markup snippet.
url = `data:text/html,
<html>
url = "data:text/html;charset=utf-8;base64,";
url += btoa(
`<html>
<head>
<meta charset="utf-8"/>
<title>Accessibility Test</title>
</head>
<body id="body">${doc}</body>
</html>`;
</html>`);
}
registerCleanupFunction(() => {
@ -284,16 +285,34 @@ function isDefunct(accessible) {
* looks for an accessible that matches based on its DOMNode id.
* @param {nsIAccessible} accessible root accessible
* @param {String} id id to look up accessible for
* @param {Array?} interfaces the interface or an array interfaces
* to query it/them from obtained accessible
* @return {nsIAccessible?} found accessible if any
*/
function findAccessibleChildByID(accessible, id) {
function findAccessibleChildByID(accessible, id, interfaces) {
if (getAccessibleDOMNodeID(accessible) === id) {
return accessible;
return queryInterfaces(accessible, interfaces);
}
for (let i = 0; i < accessible.children.length; ++i) {
let found = findAccessibleChildByID(accessible.getChildAt(i), id);
if (found) {
return found;
return queryInterfaces(found, interfaces);
}
}
}
function queryInterfaces(accessible, interfaces) {
if (!interfaces) {
return accessible;
}
for (let iface of interfaces.filter(i => !(accessible instanceof i))) {
try {
accessible.QueryInterface(iface);
} catch (e) {
ok(false, "Can't query " + iface);
}
}
return accessible;
}

1
accessible/tests/mochitest/scroll/a11y.ini
Просмотреть файл

@ -3,4 +3,3 @@ support-files =
!/accessible/tests/mochitest/*.js
[test_zoom.html]
[test_zoom_text.html]

158
accessible/tests/mochitest/scroll/test_zoom_text.html
Просмотреть файл

@ -1,158 +0,0 @@
<!DOCTYPE html>
<html>
<head>
<title>Test scrollSubstringToPoint when page is zoomed</title>
<link rel="stylesheet" type="text/css"
href="chrome://mochikit/content/tests/SimpleTest/test.css" />
<script type="application/javascript"
src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
<script type="application/javascript"
src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"></script>
<script type="application/javascript"
src="../common.js"></script>
<script type="application/javascript"
src="../role.js"></script>
<script type="application/javascript"
src="../layout.js"></script>
<script type="application/javascript"
src="../browser.js"></script>
<script type="application/javascript">
function doTest()
{
var tabDocument = currentTabDocument();
var paragraphNode = tabDocument.getElementById("paragraph");
var paragraph = getAccessible(paragraphNode, [nsIAccessibleText]);
var offset = 64; // beginning of 4th stanza
var [x, /*y*/] = getPos(paragraph);
var [docX, docY] = getPos(tabDocument);
paragraph.scrollSubstringToPoint(offset, offset,
COORDTYPE_SCREEN_RELATIVE, docX, docY);
testTextPos(paragraph, offset, [x, docY], COORDTYPE_SCREEN_RELATIVE);
zoomDocument(tabDocument, 2.0);
paragraphNode = tabDocument.getElementById("paragraph2");
paragraph = getAccessible(paragraphNode, [nsIAccessibleText]);
offset = 52; // // beginning of 4th stanza
var [x, /*y*/] = getPos(paragraph);
paragraph.scrollSubstringToPoint(offset, offset,
COORDTYPE_SCREEN_RELATIVE, docX, docY);
testTextPos(paragraph, offset, [x, docY], COORDTYPE_SCREEN_RELATIVE);
closeBrowserWindow();
SimpleTest.finish();
}
var url = "data:text/html,<html>" +
"<meta http-equiv='Content-Type' content='text/html;charset=utf-8' />" +
"<body>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br><hr>" +
"<p id='paragraph'>" +
" Пошел котик на торжок<br>" +
" Купил котик пирожок<br>" +
" Пошел котик на улочку<br>" +
" Купил котик булочку<br>" +
"</p>" +
"<hr><br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br><hr>" +
"<p id='paragraph2'>" +
" Самому ли съесть<br>" +
" Либо Сашеньке снесть<br>" +
" Я и сам укушу<br>" +
" Я и Сашеньке снесу<br>" +
"</p>" +
"<hr><br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"<br><br><br><br><br><br><br><br><br><br>" +
"</body></html>";
SimpleTest.waitForExplicitFinish();
openBrowserWindow(doTest,
url,
{ left: 0, top: 0, width: 600, height: 600 });
</script>
</head>
<body>
<a target="_blank"
href="https://bugzilla.mozilla.org/show_bug.cgi?id=727942"
title="scrollSubstringToPoint is broken when page is zoomed">
Mozilla Bug 727942
</a>
<p id="display"></p>
<div id="content" style="display: none"></div>
<pre id="test">
</pre>
</body>
</html>

8
browser/base/content/tabbrowser.css
Просмотреть файл

@ -51,14 +51,14 @@
width: 0;
}
.tab-label-container[textoverflow][dir=ltr]:not([pinned]),
.tab-label-container[textoverflow]:not([dir]):not([pinned]):-moz-locale-dir(ltr) {
.tab-label-container[textoverflow][labeldirection=ltr]:not([pinned]),
.tab-label-container[textoverflow]:not([labeldirection]):not([pinned]):-moz-locale-dir(ltr) {
direction: ltr;
mask-image: linear-gradient(to left, transparent, black 2em);
}
.tab-label-container[textoverflow][dir=rtl]:not([pinned]),
.tab-label-container[textoverflow]:not([dir]):not([pinned]):-moz-locale-dir(rtl) {
.tab-label-container[textoverflow][labeldirection=rtl]:not([pinned]),
.tab-label-container[textoverflow]:not([labeldirection]):not([pinned]):-moz-locale-dir(rtl) {
direction: rtl;
mask-image: linear-gradient(to right, transparent, black 2em);
}

4
browser/base/content/tabbrowser.xml
Просмотреть файл

@ -1549,7 +1549,7 @@
let isRTL = dwu.getDirectionFromText(aLabel) == Ci.nsIDOMWindowUtils.DIRECTION_RTL;
aTab.setAttribute("label", aLabel);
aTab.setAttribute("dir", isRTL ? "rtl" : "ltr");
aTab.setAttribute("labeldirection", isRTL ? "rtl" : "ltr");
aTab._labelIsContentTitle = aOptions && aOptions.isContentTitle;
// Dispatch TabAttrModified event unless we're setting the label
@ -7271,7 +7271,7 @@
class="tab-icon-overlay"
role="presentation"/>
<xul:hbox class="tab-label-container"
xbl:inherits="pinned,selected=visuallyselected,dir"
xbl:inherits="pinned,selected=visuallyselected,labeldirection"
onoverflow="this.setAttribute('textoverflow', 'true');"
onunderflow="this.removeAttribute('textoverflow');"
flex="1">

6
browser/components/customizableui/test/head.js
Просмотреть файл

@ -130,6 +130,12 @@ function removeNonReleaseButtons(areaPanelPlacements) {
if (isInDevEdition() && areaPanelPlacements.includes("developer-button")) {
areaPanelPlacements.splice(areaPanelPlacements.indexOf("developer-button"), 1);
}
if (AppConstants.RELEASE_OR_BETA && !AppConstants.MOZ_DEV_EDITION) {
if (areaPanelPlacements.includes("webcompat-reporter-button")) {
areaPanelPlacements.splice(areaPanelPlacements.indexOf("webcompat-reporter-button"), 1);
}
}
}
function removeNonOriginalButtons() {

6
browser/components/shell/moz.build
Просмотреть файл

@ -13,11 +13,7 @@ XPIDL_SOURCES += [
'nsIShellService.idl',
]
if CONFIG['OS_ARCH'] == 'WINNT':
XPIDL_SOURCES += [
'nsIWindowsShellService.idl',
]
elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa':
if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa':
XPIDL_SOURCES += [
'nsIMacShellService.idl',
]

17
browser/components/shell/nsIWindowsShellService.idl
Просмотреть файл

@ -1,17 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsIShellService.idl"
[scriptable, uuid(f8a26b94-49e5-4441-8fbc-315e0b4f22ef)]
interface nsIWindowsShellService : nsIShellService
{
/**
* Provides the shell service an opportunity to do some Win7+ shortcut
* maintenance needed on initial startup of the browser.
*/
void shortcutMaintenance();
};

79
browser/components/shell/nsWindowsShellService.cpp
Просмотреть файл

@ -29,10 +29,7 @@
#include "nsDirectoryServiceDefs.h"
#include "nsIWindowsRegKey.h"
#include "nsUnicharUtils.h"
#include "nsIWinTaskbar.h"
#include "nsISupportsPrimitives.h"
#include "nsIURLFormatter.h"
#include "nsThreadUtils.h"
#include "nsXULAppAPI.h"
#include "mozilla/WindowsVersion.h"
@ -65,15 +62,13 @@
#define REG_FAILED(val) \
(val != ERROR_SUCCESS)
#define NS_TASKBAR_CONTRACTID "@mozilla.org/windows-taskbar;1"
#define APP_REG_NAME_BASE L"Firefox-"
using mozilla::IsWin8OrLater;
using namespace mozilla;
using namespace mozilla::gfx;
NS_IMPL_ISUPPORTS(nsWindowsShellService, nsIWindowsShellService, nsIShellService)
NS_IMPL_ISUPPORTS(nsWindowsShellService, nsIShellService)
static nsresult
OpenKeyForReading(HKEY aKeyRoot, const nsAString& aKeyName, HKEY* aKey)
@ -136,78 +131,6 @@ LaunchHelper(nsAutoString& aPath)
return NS_OK;
}
NS_IMETHODIMP
nsWindowsShellService::ShortcutMaintenance()
{
nsresult rv;
// XXX App ids were updated to a constant install path hash,
// XXX this code can be removed after a few upgrade cycles.
// Launch helper.exe so it can update the application user model ids on
// shortcuts in the user's taskbar and start menu. This keeps older pinned
// shortcuts grouped correctly after major updates. Note, we also do this
// through the upgrade installer script, however, this is the only place we
// have a chance to trap links created by users who do control the install/
// update process of the browser.
nsCOMPtr<nsIWinTaskbar> taskbarInfo =
do_GetService(NS_TASKBAR_CONTRACTID);
if (!taskbarInfo) // If we haven't built with win7 sdk features, this fails.
return NS_OK;
// Avoid if this isn't Win7+
bool isSupported = false;
taskbarInfo->GetAvailable(&isSupported);
if (!isSupported)
return NS_OK;
nsAutoString appId;
if (NS_FAILED(taskbarInfo->GetDefaultGroupId(appId)))
return NS_ERROR_UNEXPECTED;
const char* prefName = "browser.taskbar.lastgroupid";
nsCOMPtr<nsIPrefBranch> prefs =
do_GetService(NS_PREFSERVICE_CONTRACTID);
if (!prefs)
return NS_ERROR_UNEXPECTED;
nsCOMPtr<nsISupportsString> prefString;
rv = prefs->GetComplexValue(prefName,
NS_GET_IID(nsISupportsString),
getter_AddRefs(prefString));
if (NS_SUCCEEDED(rv)) {
nsAutoString version;
prefString->GetData(version);
if (!version.IsEmpty() && version.Equals(appId)) {
// We're all good, get out of here.
return NS_OK;
}
}
// Update the version in prefs
prefString =
do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID, &rv);
if (NS_FAILED(rv))
return rv;
prefString->SetData(appId);
rv = prefs->SetComplexValue(prefName,
NS_GET_IID(nsISupportsString),
prefString);
if (NS_FAILED(rv)) {
NS_WARNING("Couldn't set last user model id!");
return NS_ERROR_UNEXPECTED;
}
nsAutoString appHelperPath;
if (NS_FAILED(GetHelperPath(appHelperPath)))
return NS_ERROR_UNEXPECTED;
appHelperPath.AppendLiteral(" /UpdateShortcutAppUserModelIds");
return LaunchHelper(appHelperPath);
}
static bool
IsPathDefaultForClass(const RefPtr<IApplicationAssociationRegistration>& pAAR,
wchar_t *exePath, LPCWSTR aClassName)

6
browser/components/shell/nsWindowsShellService.h
Просмотреть файл

@ -8,13 +8,12 @@
#include "nscore.h"
#include "nsString.h"
#include "nsIWindowsShellService.h"
#include "nsITimer.h"
#include "nsIShellService.h"
#include <windows.h>
#include <ole2.h>
class nsWindowsShellService : public nsIWindowsShellService
class nsWindowsShellService : public nsIShellService
{
virtual ~nsWindowsShellService();
@ -23,7 +22,6 @@ public:
NS_DECL_ISUPPORTS
NS_DECL_NSISHELLSERVICE
NS_DECL_NSIWINDOWSSHELLSERVICE
protected:
nsresult LaunchControlPanelDefaultsSelectionUI();

16
browser/modules/WindowsJumpLists.jsm
Просмотреть файл

@ -53,9 +53,6 @@ XPCOMUtils.defineLazyServiceGetter(this, "_idle",
XPCOMUtils.defineLazyServiceGetter(this, "_taskbarService",
"@mozilla.org/windows-taskbar;1",
"nsIWinTaskbar");
XPCOMUtils.defineLazyServiceGetter(this, "_winShellService",
"@mozilla.org/browser/shell-service;1",
"nsIWindowsShellService");
XPCOMUtils.defineLazyModuleGetter(this, "PlacesUtils",
"resource://gre/modules/PlacesUtils.jsm");
@ -136,15 +133,6 @@ this.WinTaskbarJumpList =
if (!this._initTaskbar())
return;
// Win shell shortcut maintenance. If we've gone through an update,
// this will update any pinned taskbar shortcuts. Not specific to
// jump lists, but this was a convienent place to call it.
try {
// dev builds may not have helper.exe, ignore failures.
this._shortcutMaintenance();
} catch (ex) {
}
// Store our task list config data
this._tasks = tasksCfg;
@ -180,10 +168,6 @@ this.WinTaskbarJumpList =
this._free();
},
_shortcutMaintenance: function WTBJL__maintenace() {
_winShellService.shortcutMaintenance();
},
/**
* List building
*

8
devtools/client/netmonitor/src/assets/styles/netmonitor.css
Просмотреть файл

@ -1375,5 +1375,13 @@ body,
:root[platform="linux"] .requests-list-header-button {
font-size: 85%;
}
.network-details-panel-toggle:dir(ltr)::before {
transform: rotate(90deg);
}
.network-details-panel-toggle:dir(rtl)::before {
transform: rotate(-90deg);
}
}

1
devtools/client/netmonitor/test/browser.ini
Просмотреть файл

@ -112,6 +112,7 @@ skip-if = (os == 'linux' && debug && bits == 32) # Bug 1303439
[browser_net_filter-02.js]
[browser_net_filter-03.js]
[browser_net_filter-04.js]
[browser_net_filter-autocomplete.js]
[browser_net_filter-flags.js]
[browser_net_footer-summary.js]
[browser_net_icon-preview.js]

93
devtools/client/netmonitor/test/browser_net_filter-autocomplete.js Normal file
Просмотреть файл

@ -0,0 +1,93 @@
/* Any copyright is dedicated to the Public Domain.
http://creativecommons.org/publicdomain/zero/1.0/ */
"use strict";
function testAutocompleteContents(expected, document) {
expected.forEach(function (item, i) {
is(
document
.querySelector(
`.devtools-autocomplete-listbox .autocomplete-item:nth-child(${i + 1})`
)
.textContent,
item,
`${expected[i]} found`
);
});
}
add_task(async function () {
let { monitor } = await initNetMonitor(FILTERING_URL);
let { document, window } = monitor.panelWin;
info("Starting test... ");
EventUtils.synthesizeMouseAtCenter(
document.querySelector(".devtools-filterinput"), {}, window);
// Empty Mouse click should keep autocomplete hidden
ok(!document.querySelector(".devtools-autocomplete-popup"),
"Autocomplete Popup Created");
// Typing a char should invoke a autocomplete
EventUtils.synthesizeKey("s", {});
ok(document.querySelector(".devtools-autocomplete-popup"),
"Autocomplete Popup Created");
testAutocompleteContents([
"scheme:",
"set-cookie-domain:",
"set-cookie-name:",
"set-cookie-value:",
"size:",
"status-code:",
], document);
EventUtils.synthesizeKey("c", {});
testAutocompleteContents(["scheme:"], document);
EventUtils.synthesizeKey("VK_TAB", {});
// Tab selection should hide autocomplete
ok(!document.querySelector(".devtools-autocomplete-popup"),
"Autocomplete Popup Hidden");
is(document.querySelector(".devtools-filterinput").value,
"scheme:", "Value correctly set after TAB");
// Space separated tokens
EventUtils.synthesizeKey("https ", {});
// Adding just a space should keep popup hidden
ok(!document.querySelector(".devtools-autocomplete-popup"),
"Autocomplete Popup still hidden");
// The last token where autocomplete is availabe shall generate the popup
EventUtils.synthesizeKey("p", {});
testAutocompleteContents(["protocol:"], document);
// The new value of the text box should be previousTokens + latest value selected
EventUtils.synthesizeKey("VK_RETURN", {});
is(document.querySelector(".devtools-filterinput").value,
"scheme:https protocol:", "Tokenized click generates correct value in input box");
// The negative filter flags
EventUtils.synthesizeKey(" -", {});
testAutocompleteContents([
"-cause:",
"-domain:",
"-has-response-header:",
"-is:",
"-larger-than:",
"-method:",
"-mime-type:",
"-protocol:",
"-regexp:",
"-remote-ip:",
"-scheme:",
"-set-cookie-domain:",
"-set-cookie-name:",
"-set-cookie-value:",
"-size:",
"-status-code:",
"-transferred-larger-than:",
"-transferred:",
], document);
await teardown(monitor);
});

18
dom/asmjscache/AsmJSCache.cpp
Просмотреть файл

@ -345,7 +345,7 @@ public:
ParentRunnable(const PrincipalInfo& aPrincipalInfo,
OpenMode aOpenMode,
WriteParams aWriteParams)
: mOwningThread(NS_GetCurrentThread()),
: mOwningEventTarget(GetCurrentThreadEventTarget()),
mPrincipalInfo(aPrincipalInfo),
mOpenMode(aOpenMode),
mWriteParams(aWriteParams),
@ -370,10 +370,10 @@ private:
bool
IsOnOwningThread() const
{
MOZ_ASSERT(mOwningThread);
MOZ_ASSERT(mOwningEventTarget);
bool current;
return NS_SUCCEEDED(mOwningThread->IsOnCurrentThread(&current)) && current;
return NS_SUCCEEDED(mOwningEventTarget->IsOnCurrentThread(&current)) && current;
}
void
@ -435,7 +435,7 @@ private:
mState != eFinished);
mState = eFailing;
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
}
nsresult
@ -543,7 +543,7 @@ private:
return IPC_OK();
}
nsCOMPtr<nsIEventTarget> mOwningThread;
nsCOMPtr<nsIEventTarget> mOwningEventTarget;
const PrincipalInfo mPrincipalInfo;
const OpenMode mOpenMode;
const WriteParams mWriteParams;
@ -820,7 +820,7 @@ ParentRunnable::Run()
}
mState = eWaitingToFinishInit;
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
return NS_OK;
}
@ -867,7 +867,7 @@ ParentRunnable::Run()
if (mOpenMode == eOpenForRead) {
mState = eSendingMetadataForRead;
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
return NS_OK;
}
@ -879,7 +879,7 @@ ParentRunnable::Run()
}
mState = eSendingCacheFile;
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
return NS_OK;
}
@ -909,7 +909,7 @@ ParentRunnable::Run()
}
mState = eSendingCacheFile;
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
return NS_OK;
}

3
dom/base/DispatcherTrait.cpp
Просмотреть файл

@ -24,8 +24,7 @@ DispatcherTrait::Dispatch(const char* aName,
nsIEventTarget*
DispatcherTrait::EventTargetFor(TaskCategory aCategory) const
{
nsCOMPtr<nsIEventTarget> main = do_GetMainThread();
return main;
return GetMainThreadEventTarget();
}
AbstractThread*

6
dom/base/EventSource.cpp
Просмотреть файл

@ -963,6 +963,12 @@ EventSourceImpl::IsOnCurrentThread(bool* aResult)
return NS_OK;
}
NS_IMETHODIMP_(bool)
EventSourceImpl::IsOnCurrentThreadInfallible()
{
return IsTargetThread();
}
nsresult
EventSourceImpl::GetBaseURI(nsIURI** aBaseURI)
{

18
dom/base/ImageEncoder.cpp
Просмотреть файл

@ -52,9 +52,9 @@ public:
}
already_AddRefed<gfx::DataSourceSurface> GetDataSurfaceSafe() {
nsCOMPtr<nsIThread> mainThread = do_GetMainThread();
MOZ_ASSERT(mainThread);
SyncRunnable::DispatchToThread(mainThread, this, false);
nsCOMPtr<nsIEventTarget> mainTarget = GetMainThreadEventTarget();
MOZ_ASSERT(mainTarget);
SyncRunnable::DispatchToThread(mainTarget, this, false);
return mDataSourceSurface.forget();
}
@ -90,9 +90,9 @@ public:
, mFailed(false)
{
if (!NS_IsMainThread() && workers::GetCurrentThreadWorkerPrivate()) {
mCreationThread = NS_GetCurrentThread();
mCreationEventTarget = GetCurrentThreadEventTarget();
} else {
NS_GetMainThread(getter_AddRefs(mCreationThread));
mCreationEventTarget = GetMainThreadEventTarget();
}
}
@ -126,16 +126,16 @@ public:
mFailed = true;
}
nsIThread* GetCreationThread()
nsIEventTarget* GetCreationThreadEventTarget()
{
return mCreationThread;
return mCreationEventTarget;
}
private:
uint64_t mImgSize;
nsAutoString mType;
void* mImgData;
nsCOMPtr<nsIThread> mCreationThread;
nsCOMPtr<nsIEventTarget> mCreationEventTarget;
RefPtr<EncodeCompleteCallback> mEncodeCompleteCallback;
bool mFailed;
};
@ -219,7 +219,7 @@ public:
} else {
mEncodingCompleteEvent->SetMembers(imgData, imgSize, mType);
}
rv = mEncodingCompleteEvent->GetCreationThread()->
rv = mEncodingCompleteEvent->GetCreationThreadEventTarget()->
Dispatch(mEncodingCompleteEvent, nsIThread::DISPATCH_NORMAL);
if (NS_FAILED(rv)) {
// Better to leak than to crash.

8
dom/base/StructuredCloneHolder.cpp
Просмотреть файл

@ -250,7 +250,7 @@ StructuredCloneHolder::StructuredCloneHolder(CloningSupport aSupportsCloning,
, mSupportsTransferring(aSupportsTransferring == TransferringSupported)
, mParent(nullptr)
#ifdef DEBUG
, mCreationThread(NS_GetCurrentThread())
, mCreationEventTarget(GetCurrentThreadEventTarget())
#endif
{}
@ -277,7 +277,7 @@ StructuredCloneHolder::Write(JSContext* aCx,
ErrorResult& aRv)
{
MOZ_ASSERT_IF(mStructuredCloneScope == StructuredCloneScope::SameProcessSameThread,
mCreationThread == NS_GetCurrentThread());
mCreationEventTarget->IsOnCurrentThread());
if (!StructuredCloneHolderBase::Write(aCx, aValue, aTransfer, cloneDataPolicy)) {
aRv.Throw(NS_ERROR_DOM_DATA_CLONE_ERR);
@ -292,7 +292,7 @@ StructuredCloneHolder::Read(nsISupports* aParent,
ErrorResult& aRv)
{
MOZ_ASSERT_IF(mStructuredCloneScope == StructuredCloneScope::SameProcessSameThread,
mCreationThread == NS_GetCurrentThread());
mCreationEventTarget->IsOnCurrentThread());
MOZ_ASSERT(aParent);
mozilla::AutoRestore<nsISupports*> guard(mParent);
@ -334,7 +334,7 @@ StructuredCloneHolder::ReadFromBuffer(nsISupports* aParent,
ErrorResult& aRv)
{
MOZ_ASSERT_IF(mStructuredCloneScope == StructuredCloneScope::SameProcessSameThread,
mCreationThread == NS_GetCurrentThread());
mCreationEventTarget->IsOnCurrentThread());
MOZ_ASSERT(!mBuffer, "ReadFromBuffer() must be called without a Write().");

2
dom/base/StructuredCloneHolder.h
Просмотреть файл

@ -334,7 +334,7 @@ protected:
mutable nsTArray<MessagePortIdentifier> mPortIdentifiers;
#ifdef DEBUG
nsCOMPtr<nsIThread> mCreationThread;
nsCOMPtr<nsIEventTarget> mCreationEventTarget;
#endif
};

6
dom/base/WebSocket.cpp
Просмотреть файл

@ -2880,6 +2880,12 @@ WebSocketImpl::IsOnCurrentThread(bool* aResult)
return NS_OK;
}
NS_IMETHODIMP_(bool)
WebSocketImpl::IsOnCurrentThreadInfallible()
{
return IsTargetThread();
}
bool
WebSocketImpl::IsTargetThread() const
{

5
dom/base/nsFrameMessageManager.cpp
Просмотреть файл

@ -2033,8 +2033,7 @@ nsFrameMessageManager::MarkForCC()
nsSameProcessAsyncMessageBase::nsSameProcessAsyncMessageBase(JS::RootingContext* aRootingCx,
JS::Handle<JSObject*> aCpows)
: mRootingCx(aRootingCx)
, mCpows(aRootingCx, aCpows)
: mCpows(aRootingCx, aCpows)
#ifdef DEBUG
, mCalledInit(false)
#endif
@ -2068,7 +2067,7 @@ nsSameProcessAsyncMessageBase::ReceiveMessage(nsISupports* aTarget,
// Make sure that we have called Init() and it has succeeded.
MOZ_ASSERT(mCalledInit);
if (aManager) {
SameProcessCpowHolder cpows(mRootingCx, mCpows);
SameProcessCpowHolder cpows(RootingCx(), mCpows);
RefPtr<nsFrameMessageManager> mm = aManager;
mm->ReceiveMessage(aTarget, aTargetFrameLoader, mMessage, false, &mData,

1
dom/base/nsFrameMessageManager.h
Просмотреть файл

@ -331,7 +331,6 @@ public:
private:
nsSameProcessAsyncMessageBase(const nsSameProcessAsyncMessageBase&);
JS::RootingContext* mRootingCx;
nsString mMessage;
StructuredCloneData mData;
JS::PersistentRooted<JSObject*> mCpows;

34
dom/base/nsGlobalWindow.cpp
Просмотреть файл

@ -1400,9 +1400,21 @@ bool
nsOuterWindowProxy::getOwnEnumerablePropertyKeys(JSContext *cx, JS::Handle<JSObject*> proxy,
JS::AutoIdVector &props) const
{
// BaseProxyHandler::keys seems to do what we want here: call
// ownPropertyKeys and then filter out the non-enumerable properties.
return js::BaseProxyHandler::getOwnEnumerablePropertyKeys(cx, proxy, props);
// Like ownPropertyKeys, our indexed stuff followed by our "normal" enumerable
// own property names.
//
// Note that this does not match current spec per
// https://github.com/whatwg/html/issues/2753 but as that issue says I believe
// the spec is wrong.
if (!AppendIndexedPropertyNames(cx, proxy, props)) {
return false;
}
JS::AutoIdVector innerProps(cx);
if (!js::Wrapper::getOwnEnumerablePropertyKeys(cx, proxy, innerProps)) {
return false;
}
return js::AppendUnique(cx, props, innerProps);
}
bool
@ -5139,8 +5151,22 @@ nsGlobalWindow::MayResolve(jsid aId)
void
nsGlobalWindow::GetOwnPropertyNames(JSContext* aCx, JS::AutoIdVector& aNames,
ErrorResult& aRv)
bool aEnumerableOnly, ErrorResult& aRv)
{
if (aEnumerableOnly) {
// The names we would return from here get defined on the window via one of
// two codepaths. The ones coming from the WebIDLGlobalNameHash will end up
// in the DefineConstructor function in BindingUtils, which always defines
// things as non-enumerable. The ones coming from the script namespace
// manager get defined by nsDOMClassInfo::PostCreatePrototype calling
// ResolvePrototype and using the resulting descriptot to define the
// property. ResolvePrototype always passes 0 to the FillPropertyDescriptor
// for the property attributes, so all those are non-enumerable as well.
//
// So in the aEnumerableOnly case we have nothing to do.
return;
}
MOZ_ASSERT(IsInnerWindow());
// "Components" is marked as enumerable but only resolved on demand :-/.
//aNames.AppendElement(NS_LITERAL_STRING("Components"));

2
dom/base/nsGlobalWindow.h
Просмотреть файл

@ -487,7 +487,7 @@ public:
static bool MayResolve(jsid aId);
void GetOwnPropertyNames(JSContext* aCx, JS::AutoIdVector& aNames,
mozilla::ErrorResult& aRv);
bool aEnumerableOnly, mozilla::ErrorResult& aRv);
// Object Management
static already_AddRefed<nsGlobalWindow> Create(nsGlobalWindow *aOuterWindow);

89
dom/base/nsJSEnvironment.cpp
Просмотреть файл

@ -200,8 +200,6 @@ static nsScriptNameSpaceManager *gNameSpaceManager;
static PRTime sFirstCollectionTime;
static JSContext* sContext;
static bool sIsInitialized;
static bool sDidShutdown;
static bool sShuttingDown;
@ -537,7 +535,9 @@ nsJSEnvironmentObserver::Observe(nsISupports* aSubject, const char* aTopic,
} else if (!nsCRT::strcmp(aTopic, "user-interaction-active")) {
nsJSContext::KillShrinkingGCTimer();
if (sIsCompactingOnUserInactive) {
JS::AbortIncrementalGC(sContext);
AutoJSAPI jsapi;
jsapi.Init();
JS::AbortIncrementalGC(jsapi.cx());
}
MOZ_ASSERT(!sIsCompactingOnUserInactive);
} else if (!nsCRT::strcmp(aTopic, "quit-application") ||
@ -1378,14 +1378,18 @@ nsJSContext::GarbageCollectNow(JS::gcreason::Reason aReason,
sPendingLoadCount = 0;
sLoadingInProgress = false;
if (!nsContentUtils::XPConnect() || !sContext) {
// We use danger::GetJSContext() since AutoJSAPI will assert if the current
// thread's context is null (such as during shutdown).
JSContext* cx = danger::GetJSContext();
if (!nsContentUtils::XPConnect() || !cx) {
return;
}
if (sCCLockedOut && aIncremental == IncrementalGC) {
// We're in the middle of incremental GC. Do another slice.
JS::PrepareForIncrementalGC(sContext);
JS::IncrementalGCSlice(sContext, aReason, aSliceMillis);
JS::PrepareForIncrementalGC(cx);
JS::IncrementalGCSlice(cx, aReason, aSliceMillis);
return;
}
@ -1396,15 +1400,15 @@ nsJSContext::GarbageCollectNow(JS::gcreason::Reason aReason,
}
if (sNeedsFullGC) {
JS::PrepareForFullGC(sContext);
JS::PrepareForFullGC(cx);
} else {
CycleCollectedJSRuntime::Get()->PrepareWaitingZonesForGC();
}
if (aIncremental == IncrementalGC) {
JS::StartIncrementalGC(sContext, gckind, aReason, aSliceMillis);
JS::StartIncrementalGC(cx, gckind, aReason, aSliceMillis);
} else {
JS::GCForReason(sContext, gckind, aReason);
JS::GCForReason(cx, gckind, aReason);
}
}
@ -1414,9 +1418,12 @@ FinishAnyIncrementalGC()
PROFILER_LABEL_FUNC(js::ProfileEntry::Category::GC);
if (sCCLockedOut) {
AutoJSAPI jsapi;
jsapi.Init();
// We're in the middle of an incremental GC, so finish it.
JS::PrepareForIncrementalGC(sContext);
JS::FinishIncrementalGC(sContext, JS::gcreason::CC_FORCED);
JS::PrepareForIncrementalGC(jsapi.cx());
JS::FinishIncrementalGC(jsapi.cx(), JS::gcreason::CC_FORCED);
}
}
@ -2492,7 +2499,6 @@ mozilla::dom::StartupJSEnvironment()
sNeedsFullGC = true;
sNeedsGCAfterCC = false;
gNameSpaceManager = nullptr;
sContext = nullptr;
sIsInitialized = false;
sDidShutdown = false;
sShuttingDown = false;
@ -2502,13 +2508,20 @@ mozilla::dom::StartupJSEnvironment()
sExpensiveCollectorPokes = 0;
}
static void
SetGCParameter(JSGCParamKey aParam, uint32_t aValue)
{
AutoJSAPI jsapi;
jsapi.Init();
JS_SetGCParameter(jsapi.cx(), aParam, aValue);
}
static void
SetMemoryHighWaterMarkPrefChangedCallback(const char* aPrefName, void* aClosure)
{
int32_t highwatermark = Preferences::GetInt(aPrefName, 128);
JS_SetGCParameter(sContext, JSGC_MAX_MALLOC_BYTES,
highwatermark * 1024L * 1024L);
SetGCParameter(JSGC_MAX_MALLOC_BYTES,
highwatermark * 1024L * 1024L);
}
static void
@ -2517,7 +2530,7 @@ SetMemoryMaxPrefChangedCallback(const char* aPrefName, void* aClosure)
int32_t pref = Preferences::GetInt(aPrefName, -1);
// handle overflow and negative pref values
uint32_t max = (pref <= 0 || pref >= 0x1000) ? -1 : (uint32_t)pref * 1024 * 1024;
JS_SetGCParameter(sContext, JSGC_MAX_BYTES, max);
SetGCParameter(JSGC_MAX_BYTES, max);
}
static void
@ -2533,7 +2546,8 @@ SetMemoryGCModePrefChangedCallback(const char* aPrefName, void* aClosure)
} else {
mode = JSGC_MODE_GLOBAL;
}
JS_SetGCParameter(sContext, JSGC_MODE, mode);
SetGCParameter(JSGC_MODE, mode);
}
static void
@ -2543,7 +2557,7 @@ SetMemoryGCSliceTimePrefChangedCallback(const char* aPrefName, void* aClosure)
// handle overflow and negative pref values
if (pref > 0 && pref < 100000) {
sActiveIntersliceGCBudget = pref;
JS_SetGCParameter(sContext, JSGC_SLICE_TIME_BUDGET, pref);
SetGCParameter(JSGC_SLICE_TIME_BUDGET, pref);
}
}
@ -2551,7 +2565,7 @@ static void
SetMemoryGCCompactingPrefChangedCallback(const char* aPrefName, void* aClosure)
{
bool pref = Preferences::GetBool(aPrefName);
JS_SetGCParameter(sContext, JSGC_COMPACTING_ENABLED, pref);
SetGCParameter(JSGC_COMPACTING_ENABLED, pref);
}
static void
@ -2559,29 +2573,30 @@ SetMemoryGCPrefChangedCallback(const char* aPrefName, void* aClosure)
{
int32_t pref = Preferences::GetInt(aPrefName, -1);
// handle overflow and negative pref values
if (pref >= 0 && pref < 10000)
JS_SetGCParameter(sContext, (JSGCParamKey)(intptr_t)aClosure, pref);
if (pref >= 0 && pref < 10000) {
SetGCParameter((JSGCParamKey)(intptr_t)aClosure, pref);
}
}
static void
SetMemoryGCDynamicHeapGrowthPrefChangedCallback(const char* aPrefName, void* aClosure)
{
bool pref = Preferences::GetBool(aPrefName);
JS_SetGCParameter(sContext, JSGC_DYNAMIC_HEAP_GROWTH, pref);
SetGCParameter(JSGC_DYNAMIC_HEAP_GROWTH, pref);
}
static void
SetMemoryGCDynamicMarkSlicePrefChangedCallback(const char* aPrefName, void* aClosure)
{
bool pref = Preferences::GetBool(aPrefName);
JS_SetGCParameter(sContext, JSGC_DYNAMIC_MARK_SLICE, pref);
SetGCParameter(JSGC_DYNAMIC_MARK_SLICE, pref);
}
static void
SetMemoryGCRefreshFrameSlicesEnabledPrefChangedCallback(const char* aPrefName, void* aClosure)
{
bool pref = Preferences::GetBool(aPrefName);
JS_SetGCParameter(sContext, JSGC_REFRESH_FRAME_SLICES_ENABLED, pref);
SetGCParameter(JSGC_REFRESH_FRAME_SLICES_ENABLED, pref);
}
@ -2638,12 +2653,10 @@ protected:
NS_IMETHOD Run() override
{
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(sContext == mTask->user);
AutoJSAPI jsapi;
jsapi.Init();
mTask->finish(sContext);
mTask->finish(jsapi.cx());
mTask = nullptr; // mTask may delete itself
return NS_OK;
@ -2656,8 +2669,6 @@ private:
static bool
StartAsyncTaskCallback(JSContext* aCx, JS::AsyncTask* aTask)
{
MOZ_ASSERT(aCx == sContext);
aTask->user = sContext;
return true;
}
@ -2666,13 +2677,13 @@ FinishAsyncTaskCallback(JS::AsyncTask* aTask)
{
// AsyncTasks can finish during shutdown so cannot simply
// NS_DispatchToMainThread.
nsCOMPtr<nsIThread> mainThread = do_GetMainThread();
if (!mainThread) {
nsCOMPtr<nsIEventTarget> mainTarget = GetMainThreadEventTarget();
if (!mainTarget) {
return false;
}
RefPtr<AsyncTaskRunnable> r = new AsyncTaskRunnable(aTask);
MOZ_ALWAYS_SUCCEEDS(mainThread->Dispatch(r.forget(), NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mainTarget->Dispatch(r.forget(), NS_DISPATCH_NORMAL));
return true;
}
@ -2692,15 +2703,13 @@ nsJSContext::EnsureStatics()
MOZ_CRASH();
}
sContext = danger::GetJSContext();
if (!sContext) {
MOZ_CRASH();
}
// Let's make sure that our main thread is the same as the xpcom main thread.
MOZ_ASSERT(NS_IsMainThread());
sPrevGCSliceCallback = JS::SetGCSliceCallback(sContext, DOMGCSliceCallback);
AutoJSAPI jsapi;
jsapi.Init();
sPrevGCSliceCallback = JS::SetGCSliceCallback(jsapi.cx(), DOMGCSliceCallback);
// Set up the asm.js cache callbacks
static const JS::AsmJSCacheOps asmJSCacheOps = {
@ -2709,9 +2718,9 @@ nsJSContext::EnsureStatics()
AsmJSCacheOpenEntryForWrite,
asmjscache::CloseEntryForWrite
};
JS::SetAsmJSCacheOps(sContext, &asmJSCacheOps);
JS::SetAsmJSCacheOps(jsapi.cx(), &asmJSCacheOps);
JS::SetAsyncTaskCallbacks(sContext, StartAsyncTaskCallback, FinishAsyncTaskCallback);
JS::SetAsyncTaskCallbacks(jsapi.cx(), StartAsyncTaskCallback, FinishAsyncTaskCallback);
// Set these global xpconnect options...
Preferences::RegisterCallbackAndCall(SetMemoryHighWaterMarkPrefChangedCallback,

1
dom/base/nsObjectLoadingContent.cpp
Просмотреть файл

@ -3902,6 +3902,7 @@ nsObjectLoadingContent::MayResolve(jsid aId)
void
nsObjectLoadingContent::GetOwnPropertyNames(JSContext* aCx,
JS::AutoIdVector& /* unused */,
bool /* unused */,
ErrorResult& aRv)
{
// Just like DoResolve, just make sure we're instantiated. That will do

2
dom/base/nsObjectLoadingContent.h
Просмотреть файл

@ -182,7 +182,7 @@ class nsObjectLoadingContent : public nsImageLoadingContent
// Helper for WebIDL enumeration
void GetOwnPropertyNames(JSContext* aCx, JS::AutoIdVector& /* unused */,
mozilla::ErrorResult& aRv);
bool /* unused */, mozilla::ErrorResult& aRv);
// WebIDL API
nsIDocument* GetContentDocument(nsIPrincipal& aSubjectPrincipal);

2
dom/base/test/mochitest.ini
Просмотреть файл

@ -812,9 +812,11 @@ skip-if = toolkit == 'android'
[test_window_enumeration.html]
[test_window_extensible.html]
[test_window_indexing.html]
[test_window_keys.html]
[test_window_named_frame_enumeration.html]
[test_window_orientation.html]
skip-if = true # bug 1312417
[test_window_own_props.html]
[test_window_proto.html]
[test_writable-replaceable.html]
[test_x-frame-options.html]

28
dom/base/test/test_window_keys.html Normal file
Просмотреть файл

@ -0,0 +1,28 @@
<!DOCTYPE HTML>
<html>
<!--
https://bugzilla.mozilla.org/show_bug.cgi?id=1372371
-->
<head>
<meta charset="utf-8">
<title>Test for Bug 1372371</title>
<script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
<link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
</head>
<body>
<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1372371">Mozilla Bug 1372371</a>
<p id="display"></p>
<div id="content" style="display: none">
<iframe></iframe>
</div>
<pre id="test">
</pre>
<script type="application/javascript">
/** Test for Bug 1372371 **/
var list = Object.keys(window);
is(list.indexOf("WebSocket"), -1, "WebSocket should not be enumerable");
is(list.indexOf("0"), 0, "Indexed props should be enumerable");
</script>
</body>
</html>

29
dom/base/test/test_window_own_props.html Normal file
Просмотреть файл

@ -0,0 +1,29 @@
<!DOCTYPE HTML>
<html>
<!--
https://bugzilla.mozilla.org/show_bug.cgi?id=1372371
-->
<head>
<meta charset="utf-8">
<title>Test for Bug 1372371</title>
<script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
<link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
</head>
<body>
<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1372371">Mozilla Bug 1372371</a>
<p id="display"></p>
<div id="content" style="display: none">
<iframe></iframe>
</div>
<pre id="test">
</pre>
<script type="application/javascript">
/** Test for Bug 1372371 **/
var list = Object.getOwnPropertyNames(window);
// Pick an interface name we would not have resolved here yet.
isnot(list.indexOf("WebSocket"), -1, "WebSocket should be a property");
is(list.indexOf("0"), 0, "Indexed props should be properties");
</script>
</body>
</html>

5
dom/bindings/Codegen.py
Просмотреть файл

@ -8930,7 +8930,7 @@ class CGEnumerateHook(CGAbstractBindingMethod):
def generate_code(self):
return CGGeneric(dedent("""
binding_detail::FastErrorResult rv;
self->GetOwnPropertyNames(cx, properties, rv);
self->GetOwnPropertyNames(cx, properties, enumerableOnly, rv);
if (rv.MaybeSetPendingException(cx)) {
return false;
}
@ -11196,7 +11196,8 @@ class CGEnumerateOwnPropertiesViaGetOwnPropertyNames(CGAbstractBindingMethod):
def generate_code(self):
return CGGeneric(dedent("""
binding_detail::FastErrorResult rv;
self->GetOwnPropertyNames(cx, props, rv);
// This wants all own props, not just enumerable ones.
self->GetOwnPropertyNames(cx, props, false, rv);
if (rv.MaybeSetPendingException(cx)) {
return false;
}

64
dom/cache/Context.cpp поставляемый
Просмотреть файл

@ -54,7 +54,7 @@ using mozilla::dom::quota::PersistenceType;
class Context::Data final : public Action::Data
{
public:
explicit Data(nsIThread* aTarget)
explicit Data(nsISerialEventTarget* aTarget)
: mTarget(aTarget)
{
MOZ_DIAGNOSTIC_ASSERT(mTarget);
@ -63,14 +63,14 @@ public:
virtual mozIStorageConnection*
GetConnection() const override
{
MOZ_ASSERT(mTarget == NS_GetCurrentThread());
MOZ_ASSERT(mTarget->IsOnCurrentThread());
return mConnection;
}
virtual void
SetConnection(mozIStorageConnection* aConn) override
{
MOZ_ASSERT(mTarget == NS_GetCurrentThread());
MOZ_ASSERT(mTarget->IsOnCurrentThread());
MOZ_DIAGNOSTIC_ASSERT(!mConnection);
mConnection = aConn;
MOZ_DIAGNOSTIC_ASSERT(mConnection);
@ -83,10 +83,10 @@ private:
// Context code should guarantee that we are destroyed on the target
// thread once the connection is initialized. If we're not, then
// QuotaManager might race and try to clear the origin out from under us.
MOZ_ASSERT_IF(mConnection, mTarget == NS_GetCurrentThread());
MOZ_ASSERT_IF(mConnection, mTarget->IsOnCurrentThread());
}
nsCOMPtr<nsIThread> mTarget;
nsCOMPtr<nsISerialEventTarget> mTarget;
nsCOMPtr<mozIStorageConnection> mConnection;
// Threadsafe counting because we're created on the PBackground thread
@ -104,7 +104,7 @@ public:
QuotaInitRunnable(Context* aContext,
Manager* aManager,
Data* aData,
nsIThread* aTarget,
nsISerialEventTarget* aTarget,
Action* aInitAction)
: mContext(aContext)
, mThreadsafeHandle(aContext->CreateThreadsafeHandle())
@ -112,7 +112,7 @@ public:
, mData(aData)
, mTarget(aTarget)
, mInitAction(aInitAction)
, mInitiatingThread(NS_GetCurrentThread())
, mInitiatingEventTarget(GetCurrentThreadEventTarget())
, mResult(NS_OK)
, mState(STATE_INIT)
, mCanceled(false)
@ -121,7 +121,7 @@ public:
MOZ_DIAGNOSTIC_ASSERT(mManager);
MOZ_DIAGNOSTIC_ASSERT(mData);
MOZ_DIAGNOSTIC_ASSERT(mTarget);
MOZ_DIAGNOSTIC_ASSERT(mInitiatingThread);
MOZ_DIAGNOSTIC_ASSERT(mInitiatingEventTarget);
MOZ_DIAGNOSTIC_ASSERT(mInitAction);
}
@ -215,7 +215,7 @@ private:
mState = STATE_COMPLETING;
MOZ_ALWAYS_SUCCEEDS(
mInitiatingThread->Dispatch(this, nsIThread::DISPATCH_NORMAL));
mInitiatingEventTarget->Dispatch(this, nsIThread::DISPATCH_NORMAL));
}
void Clear()
@ -231,9 +231,9 @@ private:
RefPtr<ThreadsafeHandle> mThreadsafeHandle;
RefPtr<Manager> mManager;
RefPtr<Data> mData;
nsCOMPtr<nsIThread> mTarget;
nsCOMPtr<nsISerialEventTarget> mTarget;
RefPtr<Action> mInitAction;
nsCOMPtr<nsIThread> mInitiatingThread;
nsCOMPtr<nsIEventTarget> mInitiatingEventTarget;
nsresult mResult;
QuotaInfo mQuotaInfo;
RefPtr<DirectoryLock> mDirectoryLock;
@ -384,7 +384,7 @@ Context::QuotaInitRunnable::Run()
mState = STATE_CREATE_QUOTA_MANAGER;
MOZ_ALWAYS_SUCCEEDS(
mInitiatingThread->Dispatch(this, nsIThread::DISPATCH_NORMAL));
mInitiatingEventTarget->Dispatch(this, nsIThread::DISPATCH_NORMAL));
break;
}
// ----------------------------------
@ -450,7 +450,7 @@ Context::QuotaInitRunnable::Run()
// -------------------
case STATE_RUN_ON_TARGET:
{
MOZ_ASSERT(NS_GetCurrentThread() == mTarget);
MOZ_ASSERT(mTarget->IsOnCurrentThread());
mState = STATE_RUNNING;
@ -506,14 +506,14 @@ class Context::ActionRunnable final : public nsIRunnable
, public Context::Activity
{
public:
ActionRunnable(Context* aContext, Data* aData, nsIEventTarget* aTarget,
ActionRunnable(Context* aContext, Data* aData, nsISerialEventTarget* aTarget,
Action* aAction, const QuotaInfo& aQuotaInfo)
: mContext(aContext)
, mData(aData)
, mTarget(aTarget)
, mAction(aAction)
, mQuotaInfo(aQuotaInfo)
, mInitiatingThread(NS_GetCurrentThread())
, mInitiatingThread(GetCurrentThreadEventTarget())
, mState(STATE_INIT)
, mResult(NS_OK)
, mExecutingRunOnTarget(false)
@ -556,7 +556,7 @@ public:
virtual void Resolve(nsresult aRv) override
{
MOZ_ASSERT(mTarget == NS_GetCurrentThread());
MOZ_ASSERT(mTarget->IsOnCurrentThread());
MOZ_DIAGNOSTIC_ASSERT(mState == STATE_RUNNING);
mResult = aRv;
@ -610,10 +610,10 @@ private:
RefPtr<Context> mContext;
RefPtr<Data> mData;
nsCOMPtr<nsIEventTarget> mTarget;
nsCOMPtr<nsISerialEventTarget> mTarget;
RefPtr<Action> mAction;
const QuotaInfo mQuotaInfo;
nsCOMPtr<nsIThread> mInitiatingThread;
nsCOMPtr<nsIEventTarget> mInitiatingThread;
State mState;
nsresult mResult;
@ -667,7 +667,7 @@ Context::ActionRunnable::Run()
// ----------------------
case STATE_RUN_ON_TARGET:
{
MOZ_ASSERT(NS_GetCurrentThread() == mTarget);
MOZ_ASSERT(mTarget->IsOnCurrentThread());
MOZ_DIAGNOSTIC_ASSERT(!mExecutingRunOnTarget);
// Note that we are calling RunOnTarget(). This lets us detect
@ -694,7 +694,7 @@ Context::ActionRunnable::Run()
// -----------------
case STATE_RESOLVING:
{
MOZ_ASSERT(NS_GetCurrentThread() == mTarget);
MOZ_ASSERT(mTarget->IsOnCurrentThread());
// The call to Action::RunOnTarget() must have returned now if we
// are running on the target thread again. We may now proceed
// with completion.
@ -729,7 +729,7 @@ Context::ActionRunnable::Run()
void
Context::ThreadsafeHandle::AllowToClose()
{
if (mOwningThread == NS_GetCurrentThread()) {
if (mOwningEventTarget->IsOnCurrentThread()) {
AllowToCloseOnOwningThread();
return;
}
@ -739,13 +739,13 @@ Context::ThreadsafeHandle::AllowToClose()
nsCOMPtr<nsIRunnable> runnable =
NewRunnableMethod(this, &ThreadsafeHandle::AllowToCloseOnOwningThread);
MOZ_ALWAYS_SUCCEEDS(
mOwningThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL));
mOwningEventTarget->Dispatch(runnable.forget(), nsIThread::DISPATCH_NORMAL));
}
void
Context::ThreadsafeHandle::InvalidateAndAllowToClose()
{
if (mOwningThread == NS_GetCurrentThread()) {
if (mOwningEventTarget->IsOnCurrentThread()) {
InvalidateAndAllowToCloseOnOwningThread();
return;
}
@ -755,13 +755,13 @@ Context::ThreadsafeHandle::InvalidateAndAllowToClose()
nsCOMPtr<nsIRunnable> runnable =
NewRunnableMethod(this, &ThreadsafeHandle::InvalidateAndAllowToCloseOnOwningThread);
MOZ_ALWAYS_SUCCEEDS(
mOwningThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL));
mOwningEventTarget->Dispatch(runnable.forget(), nsIThread::DISPATCH_NORMAL));
}
Context::ThreadsafeHandle::ThreadsafeHandle(Context* aContext)
: mStrongRef(aContext)
, mWeakRef(aContext)
, mOwningThread(NS_GetCurrentThread())
, mOwningEventTarget(GetCurrentThreadSerialEventTarget())
{
}
@ -771,19 +771,19 @@ Context::ThreadsafeHandle::~ThreadsafeHandle()
// however, because when we do use mStrongRef on the owning thread we are
// always holding a strong ref to the ThreadsafeHandle via the owning
// runnable. So we cannot run the ThreadsafeHandle destructor simultaneously.
if (!mStrongRef || mOwningThread == NS_GetCurrentThread()) {
if (!mStrongRef || mOwningEventTarget->IsOnCurrentThread()) {
return;
}
// Dispatch is guaranteed to succeed here because we block shutdown until
// all Contexts have been destroyed.
NS_ProxyRelease(mOwningThread, mStrongRef.forget());
NS_ProxyRelease(mOwningEventTarget, mStrongRef.forget());
}
void
Context::ThreadsafeHandle::AllowToCloseOnOwningThread()
{
MOZ_ASSERT(mOwningThread == NS_GetCurrentThread());
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
// A Context "closes" when its ref count drops to zero. Dropping this
// strong ref is necessary, but not sufficient for the close to occur.
@ -806,7 +806,7 @@ Context::ThreadsafeHandle::AllowToCloseOnOwningThread()
void
Context::ThreadsafeHandle::InvalidateAndAllowToCloseOnOwningThread()
{
MOZ_ASSERT(mOwningThread == NS_GetCurrentThread());
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
// Cancel the Context through the weak reference. This means we can
// allow the Context to close by dropping the strong ref, but then
// still cancel ongoing IO if necessary.
@ -821,7 +821,7 @@ Context::ThreadsafeHandle::InvalidateAndAllowToCloseOnOwningThread()
void
Context::ThreadsafeHandle::ContextDestroyed(Context* aContext)
{
MOZ_ASSERT(mOwningThread == NS_GetCurrentThread());
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
MOZ_DIAGNOSTIC_ASSERT(!mStrongRef);
MOZ_DIAGNOSTIC_ASSERT(mWeakRef);
MOZ_DIAGNOSTIC_ASSERT(mWeakRef == aContext);
@ -830,7 +830,7 @@ Context::ThreadsafeHandle::ContextDestroyed(Context* aContext)
// static
already_AddRefed<Context>
Context::Create(Manager* aManager, nsIThread* aTarget,
Context::Create(Manager* aManager, nsISerialEventTarget* aTarget,
Action* aInitAction, Context* aOldContext)
{
RefPtr<Context> context = new Context(aManager, aTarget, aInitAction);
@ -838,7 +838,7 @@ Context::Create(Manager* aManager, nsIThread* aTarget,
return context.forget();
}
Context::Context(Manager* aManager, nsIThread* aTarget, Action* aInitAction)
Context::Context(Manager* aManager, nsISerialEventTarget* aTarget, Action* aInitAction)
: mManager(aManager)
, mTarget(aTarget)
, mData(new Data(aTarget))

8
dom/cache/Context.h поставляемый
Просмотреть файл

@ -97,7 +97,7 @@ public:
// safe to access on owning thread.
Context* mWeakRef;
nsCOMPtr<nsIThread> mOwningThread;
nsCOMPtr<nsISerialEventTarget> mOwningEventTarget;
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(cache::Context::ThreadsafeHandle)
};
@ -118,7 +118,7 @@ public:
// will run on the QuotaManager IO thread. Note, this Action must
// be execute synchronously.
static already_AddRefed<Context>
Create(Manager* aManager, nsIThread* aTarget,
Create(Manager* aManager, nsISerialEventTarget* aTarget,
Action* aInitAction, Context* aOldContext);
// Execute given action on the target once the quota manager has been
@ -183,7 +183,7 @@ private:
RefPtr<Action> mAction;
};
Context(Manager* aManager, nsIThread* aTarget, Action* aInitAction);
Context(Manager* aManager, nsISerialEventTarget* aTarget, Action* aInitAction);
~Context();
void Init(Context* aOldContext);
void Start();
@ -202,7 +202,7 @@ private:
DoomTargetData();
RefPtr<Manager> mManager;
nsCOMPtr<nsIThread> mTarget;
nsCOMPtr<nsISerialEventTarget> mTarget;
RefPtr<Data> mData;
State mState;
bool mOrphanedData;

22
dom/cache/Manager.cpp поставляемый
Просмотреть файл

@ -649,9 +649,9 @@ private:
MOZ_DIAGNOSTIC_ASSERT(!mDBDir);
MOZ_DIAGNOSTIC_ASSERT(!mConn);
MOZ_DIAGNOSTIC_ASSERT(!mTargetThread);
mTargetThread = NS_GetCurrentThread();
MOZ_DIAGNOSTIC_ASSERT(mTargetThread);
MOZ_DIAGNOSTIC_ASSERT(!mTarget);
mTarget = GetCurrentThreadSerialEventTarget();
MOZ_DIAGNOSTIC_ASSERT(mTarget);
// We should be pre-initialized to expect one async completion. This is
// the "manual" completion we call at the end of this method in all
@ -694,7 +694,7 @@ private:
void
OnAsyncCopyComplete(nsresult aRv)
{
MOZ_ASSERT(mTargetThread == NS_GetCurrentThread());
MOZ_ASSERT(mTarget->IsOnCurrentThread());
MOZ_DIAGNOSTIC_ASSERT(mConn);
MOZ_DIAGNOSTIC_ASSERT(mResolver);
MOZ_DIAGNOSTIC_ASSERT(mExpectedAsyncCopyCompletions > 0);
@ -841,7 +841,7 @@ private:
StartStreamCopy(const QuotaInfo& aQuotaInfo, Entry& aEntry,
StreamId aStreamId, uint32_t* aCopyCountOut)
{
MOZ_ASSERT(mTargetThread == NS_GetCurrentThread());
MOZ_ASSERT(mTarget->IsOnCurrentThread());
MOZ_DIAGNOSTIC_ASSERT(aCopyCountOut);
if (IsCanceled()) {
@ -914,13 +914,13 @@ private:
nsCOMPtr<nsIRunnable> runnable = NewNonOwningRunnableMethod<nsresult>(
this, &CachePutAllAction::OnAsyncCopyComplete, aRv);
MOZ_ALWAYS_SUCCEEDS(
mTargetThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL));
mTarget->Dispatch(runnable.forget(), nsIThread::DISPATCH_NORMAL));
}
void
DoResolve(nsresult aRv)
{
MOZ_ASSERT(mTargetThread == NS_GetCurrentThread());
MOZ_ASSERT(mTarget->IsOnCurrentThread());
// DoResolve() must not be called until all async copying has completed.
#ifdef DEBUG
@ -941,7 +941,7 @@ private:
// Drop our ref to the target thread as we are done with this thread.
// Also makes our thread assertions catch any incorrect method calls
// after resolve.
mTargetThread = nullptr;
mTarget = nullptr;
// Make sure to de-ref the resolver per the Action API contract.
RefPtr<Action::Resolver> resolver;
@ -963,7 +963,7 @@ private:
RefPtr<Resolver> mResolver;
nsCOMPtr<nsIFile> mDBDir;
nsCOMPtr<mozIStorageConnection> mConn;
nsCOMPtr<nsIThread> mTargetThread;
nsCOMPtr<nsISerialEventTarget> mTarget;
nsresult mAsyncResult;
nsTArray<nsID> mBodyIdWrittenList;
@ -1783,8 +1783,8 @@ Manager::Init(Manager* aOldManager)
// per Manager now, this lets us cleanly call Factory::Remove() once the
// Context goes away.
RefPtr<Action> setupAction = new SetupAction();
RefPtr<Context> ref = Context::Create(this, mIOThread, setupAction,
oldContext);
RefPtr<Context> ref = Context::Create(this, mIOThread->SerialEventTarget(), setupAction,
oldContext);
mContext = ref;
}

6
dom/cache/PrincipalVerifier.cpp поставляемый
Просмотреть файл

@ -67,11 +67,11 @@ PrincipalVerifier::PrincipalVerifier(Listener* aListener,
const PrincipalInfo& aPrincipalInfo)
: mActor(BackgroundParent::GetContentParent(aActor))
, mPrincipalInfo(aPrincipalInfo)
, mInitiatingThread(NS_GetCurrentThread())
, mInitiatingEventTarget(GetCurrentThreadSerialEventTarget())
, mResult(NS_OK)
{
AssertIsOnBackgroundThread();
MOZ_DIAGNOSTIC_ASSERT(mInitiatingThread);
MOZ_DIAGNOSTIC_ASSERT(mInitiatingEventTarget);
MOZ_DIAGNOSTIC_ASSERT(aListener);
mListenerList.AppendElement(aListener);
@ -203,7 +203,7 @@ PrincipalVerifier::DispatchToInitiatingThread(nsresult aRv)
// This will result in a new CacheStorage object delaying operations until
// shutdown completes and the browser goes away. This is as graceful as
// we can get here.
nsresult rv = mInitiatingThread->Dispatch(this, nsIThread::DISPATCH_NORMAL);
nsresult rv = mInitiatingEventTarget->Dispatch(this, nsIThread::DISPATCH_NORMAL);
if (NS_FAILED(rv)) {
NS_WARNING("Cache unable to complete principal verification due to shutdown.");
}

2
dom/cache/PrincipalVerifier.h поставляемый
Просмотреть файл

@ -64,7 +64,7 @@ private:
RefPtr<ContentParent> mActor;
const mozilla::ipc::PrincipalInfo mPrincipalInfo;
nsCOMPtr<nsIThread> mInitiatingThread;
nsCOMPtr<nsIEventTarget> mInitiatingEventTarget;
nsresult mResult;
RefPtr<ManagerId> mManagerId;

28
dom/cache/ReadStream.cpp поставляемый
Просмотреть файл

@ -99,7 +99,7 @@ private:
StreamControl* mControl;
const nsID mId;
nsCOMPtr<nsIThread> mOwningThread;
nsCOMPtr<nsISerialEventTarget> mOwningEventTarget;
enum State
{
@ -197,7 +197,7 @@ ReadStream::Inner::Inner(StreamControl* aControl, const nsID& aId,
nsIInputStream* aStream)
: mControl(aControl)
, mId(aId)
, mOwningThread(NS_GetCurrentThread())
, mOwningEventTarget(GetCurrentThreadSerialEventTarget())
, mState(Open)
, mHasEverBeenRead(false)
, mMutex("dom::cache::ReadStream")
@ -214,7 +214,7 @@ ReadStream::Inner::Serialize(CacheReadStreamOrVoid* aReadStreamOut,
nsTArray<UniquePtr<AutoIPCStream>>& aStreamCleanupList,
ErrorResult& aRv)
{
MOZ_ASSERT(NS_GetCurrentThread() == mOwningThread);
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
MOZ_DIAGNOSTIC_ASSERT(aReadStreamOut);
*aReadStreamOut = CacheReadStream();
Serialize(&aReadStreamOut->get_CacheReadStream(), aStreamCleanupList, aRv);
@ -225,7 +225,7 @@ ReadStream::Inner::Serialize(CacheReadStream* aReadStreamOut,
nsTArray<UniquePtr<AutoIPCStream>>& aStreamCleanupList,
ErrorResult& aRv)
{
MOZ_ASSERT(NS_GetCurrentThread() == mOwningThread);
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
MOZ_DIAGNOSTIC_ASSERT(aReadStreamOut);
if (mState != Open) {
@ -254,28 +254,28 @@ ReadStream::Inner::Serialize(CacheReadStream* aReadStreamOut,
void
ReadStream::Inner::CloseStream()
{
MOZ_ASSERT(NS_GetCurrentThread() == mOwningThread);
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
Close();
}
void
ReadStream::Inner::CloseStreamWithoutReporting()
{
MOZ_ASSERT(NS_GetCurrentThread() == mOwningThread);
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
Forget();
}
bool
ReadStream::Inner::MatchId(const nsID& aId) const
{
MOZ_ASSERT(NS_GetCurrentThread() == mOwningThread);
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
return mId.Equals(aId);
}
bool
ReadStream::Inner::HasEverBeenRead() const
{
MOZ_ASSERT(NS_GetCurrentThread() == mOwningThread);
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
return mHasEverBeenRead;
}
@ -388,14 +388,14 @@ ReadStream::Inner::NoteClosed()
return;
}
if (NS_GetCurrentThread() == mOwningThread) {
if (mOwningEventTarget->IsOnCurrentThread()) {
NoteClosedOnOwningThread();
return;
}
nsCOMPtr<nsIRunnable> runnable = new NoteClosedRunnable(this);
MOZ_ALWAYS_SUCCEEDS(
mOwningThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL));
mOwningEventTarget->Dispatch(runnable.forget(), nsIThread::DISPATCH_NORMAL));
}
void
@ -406,20 +406,20 @@ ReadStream::Inner::Forget()
return;
}
if (NS_GetCurrentThread() == mOwningThread) {
if (mOwningEventTarget->IsOnCurrentThread()) {
ForgetOnOwningThread();
return;
}
nsCOMPtr<nsIRunnable> runnable = new ForgetRunnable(this);
MOZ_ALWAYS_SUCCEEDS(
mOwningThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL));
mOwningEventTarget->Dispatch(runnable.forget(), nsIThread::DISPATCH_NORMAL));
}
void
ReadStream::Inner::NoteClosedOnOwningThread()
{
MOZ_ASSERT(NS_GetCurrentThread() == mOwningThread);
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
// Mark closed and do nothing if we were already closed
if (!mState.compareExchange(Open, Closed)) {
@ -434,7 +434,7 @@ ReadStream::Inner::NoteClosedOnOwningThread()
void
ReadStream::Inner::ForgetOnOwningThread()
{
MOZ_ASSERT(NS_GetCurrentThread() == mOwningThread);
MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
// Mark closed and do nothing if we were already closed
if (!mState.compareExchange(Open, Closed)) {

10
dom/canvas/OffscreenCanvas.cpp
Просмотреть файл

@ -86,15 +86,15 @@ OffscreenCanvas::ClearResources()
mCanvasClient->Clear();
if (mCanvasRenderer) {
nsCOMPtr<nsIThread> activeThread = mCanvasRenderer->GetActiveThread();
MOZ_RELEASE_ASSERT(activeThread, "GFX: failed to get active thread.");
nsCOMPtr<nsISerialEventTarget> activeTarget = mCanvasRenderer->GetActiveEventTarget();
MOZ_RELEASE_ASSERT(activeTarget, "GFX: failed to get active event target.");
bool current;
activeThread->IsOnCurrentThread(&current);
activeTarget->IsOnCurrentThread(&current);
MOZ_RELEASE_ASSERT(current, "GFX: active thread is not current thread.");
mCanvasRenderer->SetCanvasClient(nullptr);
mCanvasRenderer->mContext = nullptr;
mCanvasRenderer->mGLContext = nullptr;
mCanvasRenderer->ResetActiveThread();
mCanvasRenderer->ResetActiveEventTarget();
}
mCanvasClient = nullptr;
@ -143,7 +143,7 @@ OffscreenCanvas::GetContext(JSContext* aCx,
WebGLContext* webGL = static_cast<WebGLContext*>(mCurrentContext.get());
gl::GLContext* gl = webGL->GL();
mCanvasRenderer->mContext = mCurrentContext;
mCanvasRenderer->SetActiveThread();
mCanvasRenderer->SetActiveEventTarget();
mCanvasRenderer->mGLContext = gl;
mCanvasRenderer->SetIsAlphaPremultiplied(webGL->IsPremultAlpha() || !gl->Caps().alpha);

13
dom/canvas/WebGLContextLossHandler.cpp
Просмотреть файл

@ -45,17 +45,16 @@ WebGLContextLossHandler::WebGLContextLossHandler(WebGLContext* webgl)
, mTimerPending(false)
, mShouldRunTimerAgain(false)
#ifdef DEBUG
, mThread(NS_GetCurrentThread())
, mEventTarget(GetCurrentThreadSerialEventTarget())
#endif
{
MOZ_ASSERT(mThread);
MOZ_ASSERT(mEventTarget);
}
WebGLContextLossHandler::~WebGLContextLossHandler()
{
// NS_GetCurrentThread() returns null during shutdown.
const DebugOnly<nsIThread*> callingThread = NS_GetCurrentThread();
MOZ_ASSERT(callingThread == mThread || !callingThread);
const DebugOnly<nsISerialEventTarget*> callingThread = GetCurrentThreadSerialEventTarget();
MOZ_ASSERT(!callingThread || mEventTarget->IsOnCurrentThread());
}
////////////////////
@ -63,7 +62,7 @@ WebGLContextLossHandler::~WebGLContextLossHandler()
void
WebGLContextLossHandler::RunTimer()
{
MOZ_ASSERT(NS_GetCurrentThread() == mThread);
MOZ_ASSERT(mEventTarget->IsOnCurrentThread());
// If the timer was already running, don't restart it here. Instead,
// wait until the previous call is done, then fire it one more time.
@ -86,7 +85,7 @@ WebGLContextLossHandler::RunTimer()
void
WebGLContextLossHandler::TimerCallback()
{
MOZ_ASSERT(NS_GetCurrentThread() == mThread);
MOZ_ASSERT(mEventTarget->IsOnCurrentThread());
mTimerPending = false;

2
dom/canvas/WebGLContextLossHandler.h
Просмотреть файл

@ -22,7 +22,7 @@ class WebGLContextLossHandler final : public SupportsWeakPtr<WebGLContextLossHan
bool mTimerPending; // that it's been discarded, and be canceled 'for our
bool mShouldRunTimerAgain; // convenience'.
#ifdef DEBUG
nsIThread* const mThread;
nsISerialEventTarget* const mEventTarget;
#endif
friend class WatchdogTimerEvent;

8
dom/crypto/WebCryptoTask.cpp
Просмотреть файл

@ -384,7 +384,7 @@ WebCryptoTask::DispatchWithPromise(Promise* aResultPromise)
}
// Store calling thread
mOriginalThread = NS_GetCurrentThread();
mOriginalEventTarget = GetCurrentThreadSerialEventTarget();
// If we are running on a worker thread we must hold the worker
// alive while we work on the thread pool. Otherwise the worker
@ -419,7 +419,7 @@ WebCryptoTask::Run()
}
// Back to the original thread, i.e. continue below.
mOriginalThread->Dispatch(this, NS_DISPATCH_NORMAL);
mOriginalEventTarget->Dispatch(this, NS_DISPATCH_NORMAL);
return NS_OK;
}
@ -3729,7 +3729,7 @@ WebCryptoTask::WebCryptoTask()
: CancelableRunnable("WebCryptoTask")
, mEarlyRv(NS_OK)
, mEarlyComplete(false)
, mOriginalThread(nullptr)
, mOriginalEventTarget(nullptr)
, mReleasedNSSResources(false)
, mRv(NS_ERROR_NOT_INITIALIZED)
{
@ -3745,7 +3745,7 @@ WebCryptoTask::~WebCryptoTask()
}
if (mWorkerHolder) {
NS_ProxyRelease(mOriginalThread, mWorkerHolder.forget());
NS_ProxyRelease(mOriginalEventTarget, mWorkerHolder.forget());
}
}

4
dom/crypto/WebCryptoTask.h
Просмотреть файл

@ -174,7 +174,7 @@ protected:
virtual ~WebCryptoTask();
bool IsOnOriginalThread() {
return !mOriginalThread || NS_GetCurrentThread() == mOriginalThread;
return !mOriginalEventTarget || mOriginalEventTarget->IsOnCurrentThread();
}
// For things that need to happen on the main thread
@ -212,7 +212,7 @@ private:
class InternalWorkerHolder;
nsCOMPtr<nsIThread> mOriginalThread;
nsCOMPtr<nsISerialEventTarget> mOriginalEventTarget;
RefPtr<InternalWorkerHolder> mWorkerHolder;
bool mReleasedNSSResources;
nsresult mRv;

2
dom/file/FileReader.cpp
Просмотреть файл

@ -120,7 +120,7 @@ FileReader::FileReader(nsIGlobalObject* aGlobal,
if (NS_IsMainThread()) {
mTarget = aGlobal->EventTargetFor(TaskCategory::Other);
} else {
mTarget = do_GetCurrentThread();
mTarget = GetCurrentThreadSerialEventTarget();
}
SetDOMStringToNull(mResult);

2
dom/file/MutableBlobStorage.cpp
Просмотреть файл

@ -371,7 +371,7 @@ MutableBlobStorage::MutableBlobStorage(MutableBlobStorageType aType,
MOZ_ASSERT(NS_IsMainThread());
if (!mEventTarget) {
mEventTarget = do_GetMainThread();
mEventTarget = GetMainThreadEventTarget();
}
MOZ_ASSERT(mEventTarget);

2
dom/file/MutableBlobStreamListener.cpp
Просмотреть файл

@ -24,7 +24,7 @@ MutableBlobStreamListener::MutableBlobStreamListener(MutableBlobStorage::Mutable
MOZ_ASSERT(aCallback);
if (!mEventTarget) {
mEventTarget = do_GetMainThread();
mEventTarget = GetMainThreadEventTarget();
}
MOZ_ASSERT(mEventTarget);

2
dom/file/ipc/IPCBlobInputStream.cpp
Просмотреть файл

@ -303,7 +303,7 @@ IPCBlobInputStream::MaybeExecuteCallback(nsIInputStreamCallback* aCallback,
return NS_OK;
}
nsCOMPtr<nsIEventTarget> target = NS_GetCurrentThread();
RefPtr<nsIEventTarget> target = GetCurrentThreadEventTarget();
return asyncStream->AsyncWait(this, 0, 0, target);
}

18
dom/file/ipc/IPCBlobInputStreamChild.cpp
Просмотреть файл

@ -131,7 +131,7 @@ IPCBlobInputStreamChild::IPCBlobInputStreamChild(const nsID& aID,
, mID(aID)
, mSize(aSize)
, mState(eActive)
, mOwningThread(NS_GetCurrentThread())
, mOwningEventTarget(GetCurrentThreadSerialEventTarget())
{
// If we are running in a worker, we need to send a Close() to the parent side
// before the thread is released.
@ -215,7 +215,7 @@ IPCBlobInputStreamChild::CreateStream()
// The stream is active but maybe it is not running in the DOM-File thread.
// We should migrate it there.
if (mState == eActive &&
!IPCBlobInputStreamThread::IsOnFileThread(mOwningThread)) {
!IPCBlobInputStreamThread::IsOnFileEventTarget(mOwningEventTarget)) {
MOZ_ASSERT(mStreams.IsEmpty());
shouldMigrate = true;
mState = eActiveMigrating;
@ -249,13 +249,13 @@ IPCBlobInputStreamChild::ForgetStream(IPCBlobInputStream* aStream)
}
}
if (mOwningThread == NS_GetCurrentThread()) {
if (mOwningEventTarget->IsOnCurrentThread()) {
Shutdown();
return;
}
RefPtr<ShutdownRunnable> runnable = new ShutdownRunnable(this);
mOwningThread->Dispatch(runnable, NS_DISPATCH_NORMAL);
mOwningEventTarget->Dispatch(runnable, NS_DISPATCH_NORMAL);
}
void
@ -281,13 +281,13 @@ IPCBlobInputStreamChild::StreamNeeded(IPCBlobInputStream* aStream,
MOZ_ASSERT(mState == eActive);
if (mOwningThread == NS_GetCurrentThread()) {
if (mOwningEventTarget->IsOnCurrentThread()) {
SendStreamNeeded();
return;
}
RefPtr<StreamNeededRunnable> runnable = new StreamNeededRunnable(this);
mOwningThread->Dispatch(runnable, NS_DISPATCH_NORMAL);
mOwningEventTarget->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL);
}
mozilla::ipc::IPCResult
@ -325,11 +325,11 @@ IPCBlobInputStreamChild::Migrated()
if (mWorkerHolder) {
RefPtr<ReleaseWorkerHolderRunnable> runnable =
new ReleaseWorkerHolderRunnable(Move(mWorkerHolder));
mOwningThread->Dispatch(runnable, NS_DISPATCH_NORMAL);
mOwningEventTarget->Dispatch(runnable, NS_DISPATCH_NORMAL);
}
mOwningThread = NS_GetCurrentThread();
MOZ_ASSERT(IPCBlobInputStreamThread::IsOnFileThread(mOwningThread));
mOwningEventTarget = GetCurrentThreadSerialEventTarget();
MOZ_ASSERT(IPCBlobInputStreamThread::IsOnFileEventTarget(mOwningEventTarget));
// Maybe we have no reasons to keep this actor alive.
if (mStreams.IsEmpty()) {

2
dom/file/ipc/IPCBlobInputStreamChild.h
Просмотреть файл

@ -108,7 +108,7 @@ private:
};
nsTArray<PendingOperation> mPendingOperations;
nsCOMPtr<nsIThread> mOwningThread;
nsCOMPtr<nsISerialEventTarget> mOwningEventTarget;
UniquePtr<workers::WorkerHolder> mWorkerHolder;
};

6
dom/file/ipc/IPCBlobInputStreamThread.cpp
Просмотреть файл

@ -91,12 +91,12 @@ NS_IMPL_ISUPPORTS_INHERITED(MigrateActorRunnable, Runnable,
NS_IMPL_ISUPPORTS(IPCBlobInputStreamThread, nsIObserver)
/* static */ bool
IPCBlobInputStreamThread::IsOnFileThread(nsIThread* aThread)
IPCBlobInputStreamThread::IsOnFileEventTarget(nsIEventTarget* aEventTarget)
{
MOZ_ASSERT(aThread);
MOZ_ASSERT(aEventTarget);
mozilla::StaticMutexAutoLock lock(gIPCBlobThreadMutex);
return gIPCBlobThread && aThread == gIPCBlobThread->mThread;
return gIPCBlobThread && aEventTarget == gIPCBlobThread->mThread;
}
/* static */ IPCBlobInputStreamThread*

2
dom/file/ipc/IPCBlobInputStreamThread.h
Просмотреть файл

@ -23,7 +23,7 @@ public:
NS_DECL_NSIOBSERVER
static bool
IsOnFileThread(nsIThread* aThread);
IsOnFileEventTarget(nsIEventTarget* aEventTarget);
static IPCBlobInputStreamThread*
GetOrCreate();

20
dom/filehandle/ActorsParent.cpp
Просмотреть файл

@ -371,7 +371,7 @@ private:
class FileHandleOp
{
protected:
nsCOMPtr<nsIEventTarget> mOwningThread;
nsCOMPtr<nsIEventTarget> mOwningEventTarget;
RefPtr<FileHandle> mFileHandle;
public:
@ -381,16 +381,16 @@ public:
AssertIsOnOwningThread() const
{
AssertIsOnBackgroundThread();
MOZ_ASSERT(mOwningThread);
MOZ_ASSERT(mOwningEventTarget);
DebugOnly<bool> current;
MOZ_ASSERT(NS_SUCCEEDED(mOwningThread->IsOnCurrentThread(&current)));
MOZ_ASSERT(NS_SUCCEEDED(mOwningEventTarget->IsOnCurrentThread(&current)));
MOZ_ASSERT(current);
}
nsIEventTarget*
OwningThread() const
{
return mOwningThread;
return mOwningEventTarget;
}
void
@ -411,7 +411,7 @@ public:
protected:
FileHandleOp(FileHandle* aFileHandle)
: mOwningThread(NS_GetCurrentThread())
: mOwningEventTarget(GetCurrentThreadSerialEventTarget())
, mFileHandle(aFileHandle)
{
AssertIsOnOwningThread();
@ -786,12 +786,12 @@ GetFileHandleThreadPoolFor(FileHandleStorage aStorage)
******************************************************************************/
FileHandleThreadPool::FileHandleThreadPool()
: mOwningThread(NS_GetCurrentThread())
: mOwningEventTarget(GetCurrentThreadSerialEventTarget())
, mShutdownRequested(false)
, mShutdownComplete(false)
{
AssertIsOnBackgroundThread();
MOZ_ASSERT(mOwningThread);
MOZ_ASSERT(mOwningEventTarget);
AssertIsOnOwningThread();
}
@ -826,10 +826,10 @@ FileHandleThreadPool::Create()
void
FileHandleThreadPool::AssertIsOnOwningThread() const
{
MOZ_ASSERT(mOwningThread);
MOZ_ASSERT(mOwningEventTarget);
bool current;
MOZ_ALWAYS_SUCCEEDS(mOwningThread->IsOnCurrentThread(&current));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->IsOnCurrentThread(&current));
MOZ_ASSERT(current);
}
@ -2252,7 +2252,7 @@ CopyFileHandleOp::DoFileWork(FileHandle* aFileHandle)
nsCOMPtr<nsIRunnable> runnable =
new ProgressRunnable(this, mOffset, mSize);
mOwningThread->Dispatch(runnable, NS_DISPATCH_NORMAL);
mOwningEventTarget->Dispatch(runnable, NS_DISPATCH_NORMAL);
} while (true);
MOZ_ASSERT(mOffset == mSize);

2
dom/filehandle/ActorsParent.h
Просмотреть файл

@ -43,7 +43,7 @@ class FileHandleThreadPool final
struct StoragesCompleteCallback;
nsCOMPtr<nsIThreadPool> mThreadPool;
nsCOMPtr<nsIEventTarget> mOwningThread;
nsCOMPtr<nsIEventTarget> mOwningEventTarget;
nsClassHashtable<nsCStringHashKey, DirectoryInfo> mDirectoryInfos;

2
dom/filesystem/FileSystemRequestParent.cpp
Просмотреть файл

@ -86,7 +86,7 @@ public:
, mActor(aActor)
, mTask(aTask)
, mPath(aPath)
, mBackgroundEventTarget(NS_GetCurrentThread())
, mBackgroundEventTarget(GetCurrentThreadEventTarget())
{
AssertIsInMainProcess();
AssertIsOnBackgroundThread();

2
dom/filesystem/FileSystemTaskBase.cpp
Просмотреть файл

@ -237,7 +237,7 @@ FileSystemTaskParentBase::FileSystemTaskParentBase(FileSystemBase* aFileSystem,
: mErrorValue(NS_OK)
, mFileSystem(aFileSystem)
, mRequestParent(aParent)
, mBackgroundEventTarget(NS_GetCurrentThread())
, mBackgroundEventTarget(GetCurrentThreadEventTarget())
{
MOZ_ASSERT(XRE_IsParentProcess(),
"Only call from parent process!");

10
dom/flyweb/HttpServer.cpp
Просмотреть файл

@ -327,7 +327,7 @@ HttpServer::Connection::Connection(nsISocketTransport* aTransport,
if (mServer->mHttps) {
SetSecurityObserver(true);
} else {
mInput->AsyncWait(this, 0, 0, NS_GetCurrentThread());
mInput->AsyncWait(this, 0, 0, GetCurrentThreadEventTarget());
}
}
@ -340,7 +340,7 @@ HttpServer::Connection::OnHandshakeDone(nsITLSServerSocket* aServer,
// XXX Verify connection security
SetSecurityObserver(false);
mInput->AsyncWait(this, 0, 0, NS_GetCurrentThread());
mInput->AsyncWait(this, 0, 0, GetCurrentThreadEventTarget());
return NS_OK;
}
@ -391,7 +391,7 @@ HttpServer::Connection::OnInputStreamReady(nsIAsyncInputStream* aStream)
&numRead);
NS_ENSURE_SUCCESS(rv, rv);
rv = mInput->AsyncWait(this, 0, 0, NS_GetCurrentThread());
rv = mInput->AsyncWait(this, 0, 0, GetCurrentThreadEventTarget());
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
@ -862,7 +862,7 @@ HttpServer::Connection::HandleWebSocketResponse(InternalResponse* aResponse)
mState = eRequestLine;
mPendingWebSocketRequest = nullptr;
mInput->AsyncWait(this, 0, 0, NS_GetCurrentThread());
mInput->AsyncWait(this, 0, 0, GetCurrentThreadEventTarget());
QueueResponse(aResponse);
}
@ -1233,7 +1233,7 @@ HttpServer::Connection::OnOutputStreamReady(nsIAsyncOutputStream* aStream)
buffer.Cut(0, written);
if (rv == NS_BASE_STREAM_WOULD_BLOCK) {
return mOutput->AsyncWait(this, 0, 0, NS_GetCurrentThread());
return mOutput->AsyncWait(this, 0, 0, GetCurrentThreadEventTarget());
}
if (NS_FAILED(rv)) {

7
dom/gamepad/ipc/GamepadEventChannelParent.cpp
Просмотреть файл

@ -45,7 +45,8 @@ GamepadEventChannelParent::GamepadEventChannelParent()
RefPtr<GamepadPlatformService> service =
GamepadPlatformService::GetParentService();
MOZ_ASSERT(service);
mBackgroundThread = NS_GetCurrentThread();
mBackgroundEventTarget = GetCurrentThreadEventTarget();
service->AddChannelParent(this);
}
@ -116,8 +117,8 @@ GamepadEventChannelParent::ActorDestroy(ActorDestroyReason aWhy)
void
GamepadEventChannelParent::DispatchUpdateEvent(const GamepadChangeEvent& aEvent)
{
mBackgroundThread->Dispatch(new SendGamepadUpdateRunnable(this, aEvent),
NS_DISPATCH_NORMAL);
mBackgroundEventTarget->Dispatch(new SendGamepadUpdateRunnable(this, aEvent),
NS_DISPATCH_NORMAL);
}
} // namespace dom

10
dom/gamepad/ipc/GamepadEventChannelParent.h
Просмотреть файл

@ -6,8 +6,8 @@
#ifndef mozilla_dom_GamepadEventChannelParent_h_
#define mozilla_dom_GamepadEventChannelParent_h_
namespace mozilla{
namespace dom{
namespace mozilla {
namespace dom {
class GamepadEventChannelParent final : public PGamepadEventChannelParent
{
@ -29,10 +29,10 @@ class GamepadEventChannelParent final : public PGamepadEventChannelParent
private:
~GamepadEventChannelParent() {}
bool mHasGamepadListener;
nsCOMPtr<nsIThread> mBackgroundThread;
nsCOMPtr<nsIEventTarget> mBackgroundEventTarget;
};
}// namespace dom
}// namespace mozilla
} // namespace dom
} // namespace mozilla
#endif

12
dom/html/HTMLCanvasElement.cpp
Просмотреть файл

@ -1375,9 +1375,9 @@ HTMLCanvasElement::OnVisibilityChange()
};
RefPtr<nsIRunnable> runnable = new Runnable(mAsyncCanvasRenderer);
nsCOMPtr<nsIThread> activeThread = mAsyncCanvasRenderer->GetActiveThread();
if (activeThread) {
activeThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL);
nsCOMPtr<nsIEventTarget> activeTarget = mAsyncCanvasRenderer->GetActiveEventTarget();
if (activeTarget) {
activeTarget->Dispatch(runnable, nsIThread::DISPATCH_NORMAL);
}
return;
}
@ -1417,9 +1417,9 @@ HTMLCanvasElement::OnMemoryPressure()
};
RefPtr<nsIRunnable> runnable = new Runnable(mAsyncCanvasRenderer);
nsCOMPtr<nsIThread> activeThread = mAsyncCanvasRenderer->GetActiveThread();
if (activeThread) {
activeThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL);
nsCOMPtr<nsIEventTarget> activeTarget = mAsyncCanvasRenderer->GetActiveEventTarget();
if (activeTarget) {
activeTarget->Dispatch(runnable, nsIThread::DISPATCH_NORMAL);
}
return;
}

12
dom/indexedDB/ActorsChild.cpp
Просмотреть файл

@ -1491,7 +1491,7 @@ class BackgroundRequestChild::PreprocessHelper final
typedef std::pair<nsCOMPtr<nsIInputStream>,
nsCOMPtr<nsIInputStream>> StreamPair;
nsCOMPtr<nsIEventTarget> mOwningThread;
nsCOMPtr<nsIEventTarget> mOwningEventTarget;
nsTArray<StreamPair> mStreamPairs;
nsTArray<RefPtr<JS::WasmModule>> mModuleSet;
BackgroundRequestChild* mActor;
@ -1509,7 +1509,7 @@ class BackgroundRequestChild::PreprocessHelper final
public:
PreprocessHelper(uint32_t aModuleSetIndex, BackgroundRequestChild* aActor)
: CancelableRunnable("indexedDB::BackgroundRequestChild::PreprocessHelper")
, mOwningThread(aActor->GetActorEventTarget())
, mOwningEventTarget(aActor->GetActorEventTarget())
, mActor(aActor)
, mCurrentBytecodeFileDesc(nullptr)
, mCurrentCompiledFileDesc(nullptr)
@ -1524,10 +1524,10 @@ public:
bool
IsOnOwningThread() const
{
MOZ_ASSERT(mOwningThread);
MOZ_ASSERT(mOwningEventTarget);
bool current;
return NS_SUCCEEDED(mOwningThread->IsOnCurrentThread(&current)) && current;
return NS_SUCCEEDED(mOwningEventTarget->IsOnCurrentThread(&current)) && current;
}
void
@ -3569,11 +3569,11 @@ PreprocessHelper::ContinueWithStatus(nsresult aStatus)
MOZ_ASSERT(mResultCode == NS_OK);
mResultCode = aStatus;
eventTarget = mOwningThread;
eventTarget = mOwningEventTarget;
} else if (mStreamPairs.IsEmpty()) {
// If all the streams have been processed, we can go back to the owning
// thread.
eventTarget = mOwningThread;
eventTarget = mOwningEventTarget;
} else {
// Continue the processing.
eventTarget = mTaskQueueEventTarget;

54
dom/indexedDB/ActorsParent.cpp
Просмотреть файл

@ -5570,7 +5570,7 @@ class ConnectionPool::ConnectionRunnable
{
protected:
DatabaseInfo* mDatabaseInfo;
nsCOMPtr<nsIEventTarget> mOwningThread;
nsCOMPtr<nsIEventTarget> mOwningEventTarget;
explicit
ConnectionRunnable(DatabaseInfo* aDatabaseInfo);
@ -5713,7 +5713,7 @@ class ConnectionPool::FinishCallbackWrapper final
{
RefPtr<ConnectionPool> mConnectionPool;
RefPtr<FinishCallback> mCallback;
nsCOMPtr<nsIEventTarget> mOwningThread;
nsCOMPtr<nsIEventTarget> mOwningEventTarget;
uint64_t mTransactionId;
bool mHasRunOnce;
@ -5911,7 +5911,7 @@ protected:
typedef nsDataHashtable<nsUint64HashKey, bool> UniqueIndexTable;
nsCOMPtr<nsIEventTarget> mOwningThread;
nsCOMPtr<nsIEventTarget> mOwningEventTarget;
const nsID mBackgroundChildLoggingId;
const uint64_t mLoggingSerialNumber;
nsresult mResultCode;
@ -5926,10 +5926,10 @@ public:
bool
IsOnOwningThread() const
{
MOZ_ASSERT(mOwningThread);
MOZ_ASSERT(mOwningEventTarget);
bool current;
return NS_SUCCEEDED(mOwningThread->IsOnCurrentThread(&current)) && current;
return NS_SUCCEEDED(mOwningEventTarget->IsOnCurrentThread(&current)) && current;
}
void
@ -5994,7 +5994,7 @@ public:
protected:
DatabaseOperationBase(const nsID& aBackgroundChildLoggingId,
uint64_t aLoggingSerialNumber)
: mOwningThread(NS_GetCurrentThread())
: mOwningEventTarget(GetCurrentThreadEventTarget())
, mBackgroundChildLoggingId(aBackgroundChildLoggingId)
, mLoggingSerialNumber(aLoggingSerialNumber)
, mResultCode(NS_OK)
@ -13184,13 +13184,13 @@ ConnectionPool::CloseDatabaseWhenIdleInternal(const nsACString& aDatabaseId)
ConnectionPool::
ConnectionRunnable::ConnectionRunnable(DatabaseInfo* aDatabaseInfo)
: mDatabaseInfo(aDatabaseInfo)
, mOwningThread(do_GetCurrentThread())
, mOwningEventTarget(GetCurrentThreadEventTarget())
{
AssertIsOnBackgroundThread();
MOZ_ASSERT(aDatabaseInfo);
MOZ_ASSERT(aDatabaseInfo->mConnectionPool);
aDatabaseInfo->mConnectionPool->AssertIsOnOwningThread();
MOZ_ASSERT(mOwningThread);
MOZ_ASSERT(mOwningEventTarget);
}
NS_IMPL_ISUPPORTS_INHERITED0(ConnectionPool::IdleConnectionRunnable,
@ -13204,7 +13204,7 @@ IdleConnectionRunnable::Run()
MOZ_ASSERT(!mDatabaseInfo->mIdle);
nsCOMPtr<nsIEventTarget> owningThread;
mOwningThread.swap(owningThread);
mOwningEventTarget.swap(owningThread);
if (owningThread) {
mDatabaseInfo->AssertIsOnConnectionThread();
@ -13250,11 +13250,11 @@ CloseConnectionRunnable::Run()
"ConnectionPool::CloseConnectionRunnable::Run",
js::ProfileEntry::Category::STORAGE);
if (mOwningThread) {
if (mOwningEventTarget) {
MOZ_ASSERT(mDatabaseInfo->mClosing);
nsCOMPtr<nsIEventTarget> owningThread;
mOwningThread.swap(owningThread);
mOwningEventTarget.swap(owningThread);
// The connection could be null if EnsureConnection() didn't run or was not
// successful in TransactionDatabaseOperationBase::RunOnConnectionThread().
@ -13351,14 +13351,14 @@ FinishCallbackWrapper::FinishCallbackWrapper(ConnectionPool* aConnectionPool,
FinishCallback* aCallback)
: mConnectionPool(aConnectionPool)
, mCallback(aCallback)
, mOwningThread(do_GetCurrentThread())
, mOwningEventTarget(GetCurrentThreadEventTarget())
, mTransactionId(aTransactionId)
, mHasRunOnce(false)
{
AssertIsOnBackgroundThread();
MOZ_ASSERT(aConnectionPool);
MOZ_ASSERT(aCallback);
MOZ_ASSERT(mOwningThread);
MOZ_ASSERT(mOwningEventTarget);
}
ConnectionPool::
@ -13376,7 +13376,7 @@ FinishCallbackWrapper::Run()
{
MOZ_ASSERT(mConnectionPool);
MOZ_ASSERT(mCallback);
MOZ_ASSERT(mOwningThread);
MOZ_ASSERT(mOwningEventTarget);
PROFILER_LABEL("IndexedDB",
"ConnectionPool::FinishCallbackWrapper::Run",
@ -13390,7 +13390,7 @@ FinishCallbackWrapper::Run()
Unused << mCallback->Run();
MOZ_ALWAYS_SUCCEEDS(
mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
return NS_OK;
}
@ -18122,7 +18122,7 @@ QuotaClient::StartIdleMaintenance()
AssertIsOnBackgroundThread();
MOZ_ASSERT(!mShutdownRequested);
mBackgroundThread = do_GetCurrentThread();
mBackgroundThread = GetCurrentThreadEventTarget();
RefPtr<Maintenance> maintenance = new Maintenance(this);
@ -21014,14 +21014,14 @@ FactoryOp::Open()
if (permission == PermissionRequestBase::kPermissionPrompt) {
mState = State::PermissionChallenge;
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
return NS_OK;
}
MOZ_ASSERT(permission == PermissionRequestBase::kPermissionAllowed);
mState = State::FinishOpen;
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
return NS_OK;
}
@ -21078,7 +21078,7 @@ FactoryOp::RetryCheckPermission()
MOZ_ASSERT(permission == PermissionRequestBase::kPermissionAllowed);
mState = State::FinishOpen;
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
return NS_OK;
}
@ -21626,7 +21626,7 @@ FactoryOp::Run()
if (IsOnOwningThread()) {
SendResults();
} else {
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
}
}
@ -21913,7 +21913,7 @@ OpenDatabaseOp::DoDatabaseWork()
State::SendingResults :
State::BeginVersionChange;
rv = mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL);
rv = mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
@ -23198,7 +23198,7 @@ DeleteDatabaseOp::DoDatabaseWork()
mState = State::SendingResults;
}
rv = mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL);
rv = mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
@ -23582,7 +23582,7 @@ VersionChangeOp::RunOnIOThread()
mDeleteDatabaseOp->mOrigin,
databaseName);
rv = mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL);
rv = mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
@ -23675,7 +23675,7 @@ VersionChangeOp::Run()
mResultCode = rv;
}
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
}
return NS_OK;
@ -23837,7 +23837,7 @@ TransactionDatabaseOperationBase::RunOnConnectionThread()
mInternalState = InternalState::SendingResults;
}
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
}
bool
@ -24359,7 +24359,7 @@ DatabaseOp::Run()
// thread.
mState = State::SendingResults;
MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
}
return NS_OK;
@ -24480,7 +24480,7 @@ CreateFileOp::DoDatabaseWork()
// thread.
mState = State::SendingResults;
rv = mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL);
rv = mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}

2
dom/indexedDB/IDBFactory.cpp
Просмотреть файл

@ -301,7 +301,7 @@ IDBFactory::CreateForJSInternal(JSContext* aCx,
factory->mOwningObject = aOwningObject;
mozilla::HoldJSObjects(factory.get());
factory->mEventTarget = NS_IsMainThread() ?
SystemGroup::EventTargetFor(TaskCategory::Other) : NS_GetCurrentThread();
SystemGroup::EventTargetFor(TaskCategory::Other) : GetCurrentThreadEventTarget();
factory->mInnerWindowID = aInnerWindowID;
factory.forget(aFactory);

5
dom/media/AbstractMediaDecoder.h
Просмотреть файл

@ -34,11 +34,6 @@ class GMPCrashHelper;
typedef nsDataHashtable<nsCStringHashKey, nsCString> MetadataTags;
static inline bool IsCurrentThread(nsIThread* aThread)
{
return NS_GetCurrentThread() == aThread;
}
/**
* The AbstractMediaDecoder class describes the public interface for a media decoder
* and is used by the MediaReader classes.

4
dom/media/GraphDriver.cpp
Просмотреть файл

@ -224,7 +224,7 @@ ThreadedDriver::Start()
// Note: mThread may be null during event->Run() if we pass to NewNamedThread! See AudioInitTask
nsresult rv = NS_NewNamedThread("MediaStreamGrph", getter_AddRefs(mThread));
if (NS_SUCCEEDED(rv)) {
mThread->Dispatch(event, NS_DISPATCH_NORMAL);
mThread->EventTarget()->Dispatch(event.forget(), NS_DISPATCH_NORMAL);
}
}
}
@ -250,7 +250,7 @@ ThreadedDriver::Revive()
NextDriver()->Start();
} else {
nsCOMPtr<nsIRunnable> event = new MediaStreamGraphInitThreadRunnable(this);
mThread->Dispatch(event, NS_DISPATCH_NORMAL);
mThread->EventTarget()->Dispatch(event.forget(), NS_DISPATCH_NORMAL);
}
}

2
dom/media/GraphDriver.h
Просмотреть файл

@ -278,7 +278,7 @@ public:
return MEDIA_GRAPH_TARGET_PERIOD_MS;
}
bool OnThread() override { return !mThread || NS_GetCurrentThread() == mThread; }
bool OnThread() override { return !mThread || mThread->EventTarget()->IsOnCurrentThread(); }
/* When the graph wakes up to do an iteration, implementations return the
* range of time that will be processed. This is called only once per

21
dom/media/MediaManager.cpp
Просмотреть файл

@ -3493,7 +3493,7 @@ SourceListener::Activate(SourceMediaStream* aStream,
}
mActivated = true;
mMainThreadCheck = PR_GetCurrentThread();
mMainThreadCheck = GetCurrentVirtualThread();
mStream = aStream;
mAudioDevice = aAudioDevice;
mVideoDevice = aVideoDevice;
@ -3699,32 +3699,31 @@ void
SourceListener::NotifyEvent(MediaStreamGraph* aGraph,
MediaStreamGraphEvent aEvent)
{
nsresult rv;
nsCOMPtr<nsIThread> thread;
nsCOMPtr<nsIEventTarget> target;
switch (aEvent) {
case MediaStreamGraphEvent::EVENT_FINISHED:
rv = NS_GetMainThread(getter_AddRefs(thread));
if (NS_WARN_IF(NS_FAILED(rv))) {
target = GetMainThreadEventTarget();
if (NS_WARN_IF(!target)) {
NS_ASSERTION(false, "Mainthread not available; running on current thread");
// Ensure this really *was* MainThread (NS_GetCurrentThread won't work)
MOZ_RELEASE_ASSERT(mMainThreadCheck == PR_GetCurrentThread());
MOZ_RELEASE_ASSERT(mMainThreadCheck == GetCurrentVirtualThread());
NotifyFinished();
return;
}
thread->Dispatch(NewRunnableMethod(this, &SourceListener::NotifyFinished),
target->Dispatch(NewRunnableMethod(this, &SourceListener::NotifyFinished),
NS_DISPATCH_NORMAL);
break;
case MediaStreamGraphEvent::EVENT_REMOVED:
rv = NS_GetMainThread(getter_AddRefs(thread));
if (NS_WARN_IF(NS_FAILED(rv))) {
target = GetMainThreadEventTarget();
if (NS_WARN_IF(!target)) {
NS_ASSERTION(false, "Mainthread not available; running on current thread");
// Ensure this really *was* MainThread (NS_GetCurrentThread won't work)
MOZ_RELEASE_ASSERT(mMainThreadCheck == PR_GetCurrentThread());
MOZ_RELEASE_ASSERT(mMainThreadCheck == GetCurrentVirtualThread());
NotifyRemoved();
return;
}
thread->Dispatch(NewRunnableMethod(this, &SourceListener::NotifyRemoved),
target->Dispatch(NewRunnableMethod(this, &SourceListener::NotifyRemoved),
NS_DISPATCH_NORMAL);
break;
case MediaStreamGraphEvent::EVENT_HAS_DIRECT_LISTENERS:

6
dom/media/MediaRecorder.cpp
Просмотреть файл

@ -271,7 +271,7 @@ class MediaRecorder::Session: public nsIObserver,
NS_IMETHOD Run() override
{
MOZ_ASSERT(NS_GetCurrentThread() == mSession->mReadThread);
MOZ_ASSERT(mSession->mReadThread->EventTarget()->IsOnCurrentThread());
LOG(LogLevel::Debug, ("Session.ExtractRunnable shutdown = %d", mSession->mEncoder->IsShutdown()));
if (!mSession->mEncoder->IsShutdown()) {
@ -609,7 +609,7 @@ private:
// PushBlobRunnable to main thread.
void Extract(bool aForceFlush)
{
MOZ_ASSERT(NS_GetCurrentThread() == mReadThread);
MOZ_ASSERT(mReadThread->EventTarget()->IsOnCurrentThread());
LOG(LogLevel::Debug, ("Session.Extract %p", this));
PROFILER_LABEL("MediaRecorder", "Session Extract",
@ -781,7 +781,7 @@ private:
nsContentUtils::RegisterShutdownObserver(this);
nsCOMPtr<nsIRunnable> event = new ExtractRunnable(this);
if (NS_FAILED(mReadThread->Dispatch(event, NS_DISPATCH_NORMAL))) {
if (NS_FAILED(mReadThread->EventTarget()->Dispatch(event.forget(), NS_DISPATCH_NORMAL))) {
NS_WARNING("Failed to dispatch ExtractRunnable at beginning");
LOG(LogLevel::Debug, ("Session.InitEncoder !ReadThread->Dispatch %p", this));
DoSessionEndTask(NS_ERROR_ABORT);

10
dom/media/TextTrackList.cpp
Просмотреть файл

@ -4,6 +4,8 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "mozilla/dom/TextTrackList.h"
#include "mozilla/DebugOnly.h"
#include "mozilla/dom/TextTrackListBinding.h"
#include "mozilla/dom/TrackEvent.h"
#include "nsThreadUtils.h"
@ -200,9 +202,9 @@ void
TextTrackList::CreateAndDispatchTrackEventRunner(TextTrack* aTrack,
const nsAString& aEventName)
{
nsCOMPtr<nsIThread> thread;
nsresult rv = NS_GetMainThread(getter_AddRefs(thread));
if (NS_FAILED(rv)) {
DebugOnly<nsresult> rv;
nsCOMPtr<nsIEventTarget> target = GetMainThreadEventTarget();
if (!target) {
// If we are not able to get the main-thread object we are shutting down.
return;
}
@ -213,7 +215,7 @@ TextTrackList::CreateAndDispatchTrackEventRunner(TextTrack* aTrack,
TrackEvent::Constructor(this, aEventName, eventInit);
// Dispatch the TrackEvent asynchronously.
rv = thread->Dispatch(do_AddRef(new TrackEventRunner(this, event)),
rv = target->Dispatch(do_AddRef(new TrackEventRunner(this, event)),
NS_DISPATCH_NORMAL);
// If we are shutting down this can file but it's still ok.

19
dom/media/VideoUtils.cpp
Просмотреть файл

@ -322,8 +322,9 @@ SimpleTimer::Cancel() {
#ifdef DEBUG
nsCOMPtr<nsIEventTarget> target;
mTimer->GetTarget(getter_AddRefs(target));
nsCOMPtr<nsIThread> thread(do_QueryInterface(target));
MOZ_ASSERT(NS_GetCurrentThread() == thread);
bool onCurrent;
nsresult rv = target->IsOnCurrentThread(&onCurrent);
MOZ_ASSERT(NS_SUCCEEDED(rv) && onCurrent);
#endif
mTimer->Cancel();
mTimer = nullptr;
@ -342,18 +343,18 @@ SimpleTimer::Notify(nsITimer *timer) {
}
nsresult
SimpleTimer::Init(nsIRunnable* aTask, uint32_t aTimeoutMs, nsIThread* aTarget)
SimpleTimer::Init(nsIRunnable* aTask, uint32_t aTimeoutMs, nsIEventTarget* aTarget)
{
nsresult rv;
// Get target thread first, so we don't have to cancel the timer if it fails.
nsCOMPtr<nsIThread> target;
nsCOMPtr<nsIEventTarget> target;
if (aTarget) {
target = aTarget;
} else {
rv = NS_GetMainThread(getter_AddRefs(target));
if (NS_FAILED(rv)) {
return rv;
target = GetMainThreadEventTarget();
if (!target) {
return NS_ERROR_NOT_AVAILABLE;
}
}
@ -363,7 +364,7 @@ SimpleTimer::Init(nsIRunnable* aTask, uint32_t aTimeoutMs, nsIThread* aTarget)
}
// Note: set target before InitWithCallback in case the timer fires before
// we change the event target.
rv = timer->SetTarget(aTarget);
rv = timer->SetTarget(target);
if (NS_FAILED(rv)) {
timer->Cancel();
return rv;
@ -381,7 +382,7 @@ SimpleTimer::Init(nsIRunnable* aTask, uint32_t aTimeoutMs, nsIThread* aTarget)
NS_IMPL_ISUPPORTS(SimpleTimer, nsITimerCallback)
already_AddRefed<SimpleTimer>
SimpleTimer::Create(nsIRunnable* aTask, uint32_t aTimeoutMs, nsIThread* aTarget)
SimpleTimer::Create(nsIRunnable* aTask, uint32_t aTimeoutMs, nsIEventTarget* aTarget)
{
RefPtr<SimpleTimer> t(new SimpleTimer());
if (NS_FAILED(t->Init(aTask, aTimeoutMs, aTarget))) {

4
dom/media/VideoUtils.h
Просмотреть файл

@ -287,14 +287,14 @@ public:
// on thread aTarget. If aTarget is null, task is run on the main thread.
static already_AddRefed<SimpleTimer> Create(nsIRunnable* aTask,
uint32_t aTimeoutMs,
nsIThread* aTarget = nullptr);
nsIEventTarget* aTarget = nullptr);
void Cancel();
NS_IMETHOD Notify(nsITimer *timer) override;
private:
virtual ~SimpleTimer() {}
nsresult Init(nsIRunnable* aTask, uint32_t aTimeoutMs, nsIThread* aTarget);
nsresult Init(nsIRunnable* aTask, uint32_t aTimeoutMs, nsIEventTarget* aTarget);
RefPtr<nsIRunnable> mTask;
nsCOMPtr<nsITimer> mTimer;

21
dom/media/gmp/GMPCDMProxy.cpp
Просмотреть файл

@ -10,7 +10,6 @@
#include "mozilla/dom/MediaKeys.h"
#include "mozilla/dom/MediaKeySession.h"
#include "mozIGeckoMediaPluginService.h"
#include "nsPrintfCString.h"
#include "nsString.h"
@ -96,14 +95,14 @@ GMPCDMProxy::Init(PromiseId aPromiseId,
NewRunnableMethod<UniquePtr<InitData>&&>(this,
&GMPCDMProxy::gmp_Init,
Move(data)));
mOwnerThread->Dispatch(task, NS_DISPATCH_NORMAL);
mOwnerThread->EventTarget()->Dispatch(task.forget(), NS_DISPATCH_NORMAL);
}
#ifdef DEBUG
bool
GMPCDMProxy::IsOnOwnerThread()
{
return NS_GetCurrentThread() == mOwnerThread;
return mOwnerThread->IsOnCurrentThread();
}
#endif
@ -298,7 +297,7 @@ GMPCDMProxy::CreateSession(uint32_t aCreateSessionToken,
NewRunnableMethod<UniquePtr<CreateSessionData>&&>(this,
&GMPCDMProxy::gmp_CreateSession,
Move(data)));
mOwnerThread->Dispatch(task, NS_DISPATCH_NORMAL);
mOwnerThread->EventTarget()->Dispatch(task.forget(), NS_DISPATCH_NORMAL);
}
GMPSessionType
@ -341,7 +340,7 @@ GMPCDMProxy::LoadSession(PromiseId aPromiseId,
NewRunnableMethod<UniquePtr<SessionOpData>&&>(this,
&GMPCDMProxy::gmp_LoadSession,
Move(data)));
mOwnerThread->Dispatch(task, NS_DISPATCH_NORMAL);
mOwnerThread->EventTarget()->Dispatch(task.forget(), NS_DISPATCH_NORMAL);
}
void
@ -371,7 +370,7 @@ GMPCDMProxy::SetServerCertificate(PromiseId aPromiseId,
NewRunnableMethod<UniquePtr<SetServerCertificateData>&&>(this,
&GMPCDMProxy::gmp_SetServerCertificate,
Move(data)));
mOwnerThread->Dispatch(task, NS_DISPATCH_NORMAL);
mOwnerThread->EventTarget()->Dispatch(task.forget(), NS_DISPATCH_NORMAL);
}
void
@ -403,7 +402,7 @@ GMPCDMProxy::UpdateSession(const nsAString& aSessionId,
NewRunnableMethod<UniquePtr<UpdateSessionData>&&>(this,
&GMPCDMProxy::gmp_UpdateSession,
Move(data)));
mOwnerThread->Dispatch(task, NS_DISPATCH_NORMAL);
mOwnerThread->EventTarget()->Dispatch(task.forget(), NS_DISPATCH_NORMAL);
}
void
@ -434,7 +433,7 @@ GMPCDMProxy::CloseSession(const nsAString& aSessionId,
NewRunnableMethod<UniquePtr<SessionOpData>&&>(this,
&GMPCDMProxy::gmp_CloseSession,
Move(data)));
mOwnerThread->Dispatch(task, NS_DISPATCH_NORMAL);
mOwnerThread->EventTarget()->Dispatch(task.forget(), NS_DISPATCH_NORMAL);
}
void
@ -463,7 +462,7 @@ GMPCDMProxy::RemoveSession(const nsAString& aSessionId,
NewRunnableMethod<UniquePtr<SessionOpData>&&>(this,
&GMPCDMProxy::gmp_RemoveSession,
Move(data)));
mOwnerThread->Dispatch(task, NS_DISPATCH_NORMAL);
mOwnerThread->EventTarget()->Dispatch(task.forget(), NS_DISPATCH_NORMAL);
}
void
@ -486,7 +485,7 @@ GMPCDMProxy::Shutdown()
// Note: This may end up being the last owning reference to the GMPCDMProxy.
nsCOMPtr<nsIRunnable> task(NewRunnableMethod(this, &GMPCDMProxy::gmp_Shutdown));
if (mOwnerThread) {
mOwnerThread->Dispatch(task, NS_DISPATCH_NORMAL);
mOwnerThread->EventTarget()->Dispatch(task.forget(), NS_DISPATCH_NORMAL);
}
}
@ -686,7 +685,7 @@ GMPCDMProxy::Decrypt(MediaRawData* aSample)
nsCOMPtr<nsIRunnable> task(
NewRunnableMethod<RefPtr<DecryptJob>>(this, &GMPCDMProxy::gmp_Decrypt, job));
mOwnerThread->Dispatch(task, NS_DISPATCH_NORMAL);
mOwnerThread->EventTarget()->Dispatch(task.forget(), NS_DISPATCH_NORMAL);
return promise;
}

31
dom/media/gmp/GMPContentParent.cpp
Просмотреть файл

@ -74,13 +74,13 @@ GMPContentParent::ActorDestroy(ActorDestroyReason aWhy)
void
GMPContentParent::CheckThread()
{
MOZ_ASSERT(mGMPThread == NS_GetCurrentThread());
MOZ_ASSERT(GMPEventTarget()->IsOnCurrentThread());
}
void
GMPContentParent::ChromiumCDMDestroyed(ChromiumCDMParent* aDecoder)
{
MOZ_ASSERT(GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(GMPEventTarget()->IsOnCurrentThread());
MOZ_ALWAYS_TRUE(mChromiumCDMs.RemoveElement(aDecoder));
CloseIfUnused();
@ -89,7 +89,7 @@ GMPContentParent::ChromiumCDMDestroyed(ChromiumCDMParent* aDecoder)
void
GMPContentParent::VideoDecoderDestroyed(GMPVideoDecoderParent* aDecoder)
{
MOZ_ASSERT(GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(GMPEventTarget()->IsOnCurrentThread());
// If the constructor fails, we'll get called before it's added
Unused << NS_WARN_IF(!mVideoDecoders.RemoveElement(aDecoder));
@ -99,7 +99,7 @@ GMPContentParent::VideoDecoderDestroyed(GMPVideoDecoderParent* aDecoder)
void
GMPContentParent::VideoEncoderDestroyed(GMPVideoEncoderParent* aEncoder)
{
MOZ_ASSERT(GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(GMPEventTarget()->IsOnCurrentThread());
// If the constructor fails, we'll get called before it's added
Unused << NS_WARN_IF(!mVideoEncoders.RemoveElement(aEncoder));
@ -109,7 +109,7 @@ GMPContentParent::VideoEncoderDestroyed(GMPVideoEncoderParent* aEncoder)
void
GMPContentParent::DecryptorDestroyed(GMPDecryptorParent* aSession)
{
MOZ_ASSERT(GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(GMPEventTarget()->IsOnCurrentThread());
MOZ_ALWAYS_TRUE(mDecryptors.RemoveElement(aSession));
CloseIfUnused();
@ -118,14 +118,14 @@ GMPContentParent::DecryptorDestroyed(GMPDecryptorParent* aSession)
void
GMPContentParent::AddCloseBlocker()
{
MOZ_ASSERT(GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(GMPEventTarget()->IsOnCurrentThread());
++mCloseBlockerCount;
}
void
GMPContentParent::RemoveCloseBlocker()
{
MOZ_ASSERT(GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(GMPEventTarget()->IsOnCurrentThread());
--mCloseBlockerCount;
CloseIfUnused();
}
@ -167,25 +167,28 @@ GMPContentParent::GetGMPDecryptor(GMPDecryptorParent** aGMPDP)
return NS_OK;
}
nsCOMPtr<nsIThread>
GMPContentParent::GMPThread()
nsCOMPtr<nsISerialEventTarget>
GMPContentParent::GMPEventTarget()
{
if (!mGMPThread) {
if (!mGMPEventTarget) {
nsCOMPtr<mozIGeckoMediaPluginService> mps = do_GetService("@mozilla.org/gecko-media-plugin-service;1");
MOZ_ASSERT(mps);
if (!mps) {
return nullptr;
}
// Not really safe if we just grab to the mGMPThread, as we don't know
// Not really safe if we just grab to the mGMPEventTarget, as we don't know
// what thread we're running on and other threads may be trying to
// access this without locks! However, debug only, and primary failure
// mode outside of compiler-helped TSAN is a leak. But better would be
// to use swap() under a lock.
mps->GetThread(getter_AddRefs(mGMPThread));
MOZ_ASSERT(mGMPThread);
nsCOMPtr<nsIThread> gmpThread;
mps->GetThread(getter_AddRefs(gmpThread));
MOZ_ASSERT(gmpThread);
mGMPEventTarget = gmpThread->SerialEventTarget();
}
return mGMPThread;
return mGMPEventTarget;
}
already_AddRefed<ChromiumCDMParent>

4
dom/media/gmp/GMPContentParent.h
Просмотреть файл

@ -40,7 +40,7 @@ public:
already_AddRefed<ChromiumCDMParent> GetChromiumCDM();
void ChromiumCDMDestroyed(ChromiumCDMParent* aCDM);
nsCOMPtr<nsIThread> GMPThread();
nsCOMPtr<nsISerialEventTarget> GMPEventTarget();
// GMPSharedMem
void CheckThread() override;
@ -111,7 +111,7 @@ private:
nsTArray<RefPtr<GMPVideoEncoderParent>> mVideoEncoders;
nsTArray<RefPtr<GMPDecryptorParent>> mDecryptors;
nsTArray<RefPtr<ChromiumCDMParent>> mChromiumCDMs;
nsCOMPtr<nsIThread> mGMPThread;
nsCOMPtr<nsISerialEventTarget> mGMPEventTarget;
RefPtr<GMPParent> mParent;
nsCString mDisplayName;
uint32_t mPluginId;

8
dom/media/gmp/GMPDecryptorParent.cpp
Просмотреть файл

@ -31,10 +31,10 @@ GMPDecryptorParent::GMPDecryptorParent(GMPContentParent* aPlugin)
, mPluginId(aPlugin->GetPluginId())
, mCallback(nullptr)
#ifdef DEBUG
, mGMPThread(aPlugin->GMPThread())
, mGMPEventTarget(aPlugin->GMPEventTarget())
#endif
{
MOZ_ASSERT(mPlugin && mGMPThread);
MOZ_ASSERT(mPlugin && mGMPEventTarget);
}
GMPDecryptorParent::~GMPDecryptorParent()
@ -437,7 +437,7 @@ void
GMPDecryptorParent::Close()
{
LOGD(("GMPDecryptorParent[%p]::Close()", this));
MOZ_ASSERT(mGMPThread == NS_GetCurrentThread());
MOZ_ASSERT(mGMPEventTarget->IsOnCurrentThread());
// Consumer is done with us; we can shut down. No more callbacks should
// be made to mCallback. Note: do this before Shutdown()!
@ -454,7 +454,7 @@ void
GMPDecryptorParent::Shutdown()
{
LOGD(("GMPDecryptorParent[%p]::Shutdown()", this));
MOZ_ASSERT(mGMPThread == NS_GetCurrentThread());
MOZ_ASSERT(mGMPEventTarget->IsOnCurrentThread());
if (mShuttingDown) {
return;

2
dom/media/gmp/GMPDecryptorParent.h
Просмотреть файл

@ -119,7 +119,7 @@ private:
uint32_t mPluginId;
GMPDecryptorProxyCallback* mCallback;
#ifdef DEBUG
nsCOMPtr<nsIThread> const mGMPThread;
nsCOMPtr<nsISerialEventTarget> const mGMPEventTarget;
#endif
};

42
dom/media/gmp/GMPParent.cpp
Просмотреть файл

@ -86,7 +86,7 @@ GMPParent::~GMPParent()
nsresult
GMPParent::CloneFrom(const GMPParent* aOther)
{
MOZ_ASSERT(GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(GMPEventTarget()->IsOnCurrentThread());
MOZ_ASSERT(aOther->mDirectory && aOther->mService, "null plugin directory");
mService = aOther->mService;
@ -110,7 +110,7 @@ GMPParent::Init(GeckoMediaPluginServiceParent* aService, nsIFile* aPluginDir)
{
MOZ_ASSERT(aPluginDir);
MOZ_ASSERT(aService);
MOZ_ASSERT(GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(GMPEventTarget()->IsOnCurrentThread());
mService = aService;
mDirectory = aPluginDir;
@ -147,7 +147,7 @@ nsresult
GMPParent::LoadProcess()
{
MOZ_ASSERT(mDirectory, "Plugin directory cannot be NULL!");
MOZ_ASSERT(GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(GMPEventTarget()->IsOnCurrentThread());
MOZ_ASSERT(mState == GMPStateNotLoaded);
nsAutoString path;
@ -222,7 +222,7 @@ GMPParent::RecvPGMPContentChildDestroyed()
void
GMPParent::CloseIfUnused()
{
MOZ_ASSERT(GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(GMPEventTarget()->IsOnCurrentThread());
LOGD("%s", __FUNCTION__);
if ((mDeleteProcessOnlyOnUnload ||
@ -247,7 +247,7 @@ void
GMPParent::CloseActive(bool aDieWhenUnloaded)
{
LOGD("%s: state %d", __FUNCTION__, mState);
MOZ_ASSERT(GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(GMPEventTarget()->IsOnCurrentThread());
if (aDieWhenUnloaded) {
mDeleteProcessOnlyOnUnload = true; // don't allow this to go back...
@ -278,7 +278,7 @@ void
GMPParent::Shutdown()
{
LOGD("%s", __FUNCTION__);
MOZ_ASSERT(GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(GMPEventTarget()->IsOnCurrentThread());
if (mAbnormalShutdownInProgress) {
return;
@ -324,20 +324,20 @@ void
GMPParent::ChildTerminated()
{
RefPtr<GMPParent> self(this);
nsCOMPtr<nsIThread> gmpThread = GMPThread();
nsCOMPtr<nsISerialEventTarget> gmpEventTarget = GMPEventTarget();
if (!gmpThread) {
if (!gmpEventTarget) {
// Bug 1163239 - this can happen on shutdown.
// PluginTerminated removes the GMP from the GMPService.
// On shutdown we can have this case where it is already been
// removed so there is no harm in not trying to remove it again.
LOGD("%s::%s: GMPThread() returned nullptr.", __CLASS__, __FUNCTION__);
LOGD("%s::%s: GMPEventTarget() returned nullptr.", __CLASS__, __FUNCTION__);
} else {
gmpThread->Dispatch(NewRunnableMethod<RefPtr<GMPParent>>(
mService,
&GeckoMediaPluginServiceParent::PluginTerminated,
self),
NS_DISPATCH_NORMAL);
gmpEventTarget->Dispatch(NewRunnableMethod<RefPtr<GMPParent>>(
mService,
&GeckoMediaPluginServiceParent::PluginTerminated,
self),
NS_DISPATCH_NORMAL);
}
}
@ -373,8 +373,8 @@ GMPParent::State() const
return mState;
}
nsCOMPtr<nsIThread>
GMPParent::GMPThread()
nsCOMPtr<nsISerialEventTarget>
GMPParent::GMPEventTarget()
{
nsCOMPtr<mozIGeckoMediaPluginService> mps =
do_GetService("@mozilla.org/gecko-media-plugin-service;1");
@ -386,7 +386,7 @@ GMPParent::GMPThread()
// nullptr if the GeckoMediaPluginService has started shutdown.
nsCOMPtr<nsIThread> gmpThread;
mps->GetThread(getter_AddRefs(gmpThread));
return gmpThread;
return gmpThread ? gmpThread->SerialEventTarget() : nullptr;
}
/* static */
@ -584,8 +584,8 @@ GMPParent::RecvPGMPTimerConstructor(PGMPTimerParent* actor)
PGMPTimerParent*
GMPParent::AllocPGMPTimerParent()
{
nsCOMPtr<nsIThread> thread = GMPThread();
GMPTimerParent* p = new GMPTimerParent(thread);
nsCOMPtr<nsISerialEventTarget> target = GMPEventTarget();
GMPTimerParent* p = new GMPTimerParent(target);
mTimers.AppendElement(p); // Released in DeallocPGMPTimerParent, or on shutdown.
return p;
}
@ -891,7 +891,7 @@ GMPParent::ResolveGetContentParentPromises()
bool
GMPParent::OpenPGMPContent()
{
MOZ_ASSERT(GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(GMPEventTarget()->IsOnCurrentThread());
MOZ_ASSERT(!mGMPContentParent);
Endpoint<PGMPContentParent> parent;
@ -931,7 +931,7 @@ void
GMPParent::GetGMPContentParent(UniquePtr<MozPromiseHolder<GetGMPContentParentPromise>>&& aPromiseHolder)
{
LOGD("%s %p", __FUNCTION__, this);
MOZ_ASSERT(GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(GMPEventTarget()->IsOnCurrentThread());
if (mGMPContentParent) {
RefPtr<GMPContentParent::CloseBlocker> blocker(new GMPContentParent::CloseBlocker(mGMPContentParent));

4
dom/media/gmp/GMPParent.h
Просмотреть файл

@ -22,8 +22,6 @@
#include "nsIFile.h"
#include "mozilla/MozPromise.h"
class nsIThread;
#ifdef MOZ_CRASHREPORTER
#include "nsExceptionHandler.h"
#endif
@ -100,7 +98,7 @@ public:
void DeleteProcess();
GMPState State() const;
nsCOMPtr<nsIThread> GMPThread();
nsCOMPtr<nsISerialEventTarget> GMPEventTarget();
// A GMP can either be a single instance shared across all NodeIds (like
// in the OpenH264 case), or we can require a new plugin instance for every

8
dom/media/gmp/GMPService.cpp
Просмотреть файл

@ -234,7 +234,7 @@ GeckoMediaPluginService::GetCDM(const NodeId& aNodeId,
nsTArray<nsCString> aTags,
GMPCrashHelper* aHelper)
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
if (mShuttingDownOnGMPThread || aTags.IsEmpty()) {
return GetCDMParentPromise::CreateAndReject(NS_ERROR_FAILURE, __func__);
@ -354,7 +354,7 @@ GeckoMediaPluginService::GetDecryptingGMPVideoDecoder(GMPCrashHelper* aHelper,
UniquePtr<GetGMPVideoDecoderCallback>&& aCallback,
uint32_t aDecryptorId)
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
NS_ENSURE_ARG(aTags && aTags->Length() > 0);
NS_ENSURE_ARG(aCallback);
@ -392,7 +392,7 @@ GeckoMediaPluginService::GetGMPVideoEncoder(GMPCrashHelper* aHelper,
const nsACString& aNodeId,
UniquePtr<GetGMPVideoEncoderCallback>&& aCallback)
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
NS_ENSURE_ARG(aTags && aTags->Length() > 0);
NS_ENSURE_ARG(aCallback);
@ -438,7 +438,7 @@ GeckoMediaPluginService::GetGMPDecryptor(GMPCrashHelper* aHelper,
}
#endif
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
NS_ENSURE_ARG(aTags && aTags->Length() > 0);
NS_ENSURE_ARG(aCallback);

14
dom/media/gmp/GMPServiceChild.cpp
Просмотреть файл

@ -58,7 +58,7 @@ GeckoMediaPluginServiceChild::GetContentParent(GMPCrashHelper* aHelper,
const nsCString& aAPI,
const nsTArray<nsCString>& aTags)
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
MozPromiseHolder<GetGMPContentParentPromise>* rawHolder = new MozPromiseHolder<GetGMPContentParentPromise>();
RefPtr<GetGMPContentParentPromise> promise = rawHolder->Ensure(__func__);
@ -133,7 +133,7 @@ GeckoMediaPluginServiceChild::GetContentParent(GMPCrashHelper* aHelper,
const nsCString& aAPI,
const nsTArray<nsCString>& aTags)
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
MozPromiseHolder<GetGMPContentParentPromise>* rawHolder =
new MozPromiseHolder<GetGMPContentParentPromise>();
@ -296,7 +296,7 @@ GeckoMediaPluginServiceChild::UpdateGMPCapabilities(nsTArray<GMPCapabilityData>&
void
GeckoMediaPluginServiceChild::BeginShutdown()
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
mShuttingDownOnGMPThread = true;
}
@ -329,7 +329,7 @@ GeckoMediaPluginServiceChild::GetNodeId(const nsAString& aOrigin,
const nsAString& aGMPName,
UniquePtr<GetNodeIdCallback>&& aCallback)
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
GetNodeIdCallback* rawCallback = aCallback.release();
RefPtr<AbstractThread> thread(GetAbstractGMPThread());
@ -378,7 +378,7 @@ GeckoMediaPluginServiceChild::Observe(nsISupports* aSubject,
RefPtr<GeckoMediaPluginServiceChild::GetServiceChildPromise>
GeckoMediaPluginServiceChild::GetServiceChild()
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
if (!mServiceChild) {
if (mShuttingDownOnGMPThread) {
@ -407,7 +407,7 @@ GeckoMediaPluginServiceChild::GetServiceChild()
void
GeckoMediaPluginServiceChild::SetServiceChild(UniquePtr<GMPServiceChild>&& aServiceChild)
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
mServiceChild = Move(aServiceChild);
@ -421,7 +421,7 @@ GeckoMediaPluginServiceChild::SetServiceChild(UniquePtr<GMPServiceChild>&& aServ
void
GeckoMediaPluginServiceChild::RemoveGMPContentParent(GMPContentParent* aGMPContentParent)
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
if (mServiceChild) {
mServiceChild->RemoveGMPContentParent(aGMPContentParent);

30
dom/media/gmp/GMPServiceParent.cpp
Просмотреть файл

@ -403,7 +403,7 @@ GeckoMediaPluginServiceParent::GetContentParent(
const nsCString& aAPI,
const nsTArray<nsCString>& aTags)
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
nsCString nodeIdString;
nsresult rv = GetNodeId(
@ -452,14 +452,14 @@ GeckoMediaPluginServiceParent::NotifySyncShutdownComplete()
bool
GeckoMediaPluginServiceParent::IsShuttingDown()
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
return mShuttingDownOnGMPThread;
}
void
GeckoMediaPluginServiceParent::UnloadPlugins()
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
MOZ_ASSERT(!mShuttingDownOnGMPThread);
mShuttingDownOnGMPThread = true;
@ -499,7 +499,7 @@ void
GeckoMediaPluginServiceParent::CrashPlugins()
{
LOGD(("%s::%s", __CLASS__, __FUNCTION__));
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
MutexAutoLock lock(mMutex);
for (size_t i = 0; i < mPlugins.Length(); i++) {
@ -510,7 +510,7 @@ GeckoMediaPluginServiceParent::CrashPlugins()
RefPtr<GenericPromise::AllPromiseType>
GeckoMediaPluginServiceParent::LoadFromEnvironment()
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
RefPtr<AbstractThread> thread(GetAbstractGMPThread());
if (!thread) {
return GenericPromise::AllPromiseType::CreateAndReject(NS_ERROR_FAILURE, __func__);
@ -760,7 +760,7 @@ GeckoMediaPluginServiceParent::SelectPluginForAPI(const nsACString& aNodeId,
const nsCString& aAPI,
const nsTArray<nsCString>& aTags)
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread,
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread(),
"Can't clone GMP plugins on non-GMP threads.");
GMPParent* gmpToClone = nullptr;
@ -852,7 +852,7 @@ GeckoMediaPluginServiceParent::AddOnGMPThread(nsString aDirectory)
std::replace(aDirectory.BeginWriting(), aDirectory.EndWriting(), '/', '\\');
#endif
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
nsCString dir = NS_ConvertUTF16toUTF8(aDirectory);
RefPtr<AbstractThread> thread(GetAbstractGMPThread());
if (!thread) {
@ -896,7 +896,7 @@ GeckoMediaPluginServiceParent::RemoveOnGMPThread(const nsAString& aDirectory,
const bool aDeleteFromDisk,
const bool aCanDefer)
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
LOGD(("%s::%s: %s", __CLASS__, __FUNCTION__, NS_LossyConvertUTF16toASCII(aDirectory).get()));
nsCOMPtr<nsIFile> directory;
@ -971,7 +971,7 @@ static void Dummy(RefPtr<GMPParent>& aOnDeathsDoor)
void
GeckoMediaPluginServiceParent::PluginTerminated(const RefPtr<GMPParent>& aPlugin)
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
if (aPlugin->IsMarkedForDeletion()) {
nsCString path8;
@ -989,7 +989,7 @@ GeckoMediaPluginServiceParent::PluginTerminated(const RefPtr<GMPParent>& aPlugin
void
GeckoMediaPluginServiceParent::ReAddOnGMPThread(const RefPtr<GMPParent>& aOld)
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
LOGD(("%s::%s: %p", __CLASS__, __FUNCTION__, (void*) aOld));
RefPtr<GMPParent> gmp;
@ -1117,7 +1117,7 @@ NS_IMETHODIMP
GeckoMediaPluginServiceParent::IsPersistentStorageAllowed(const nsACString& aNodeId,
bool* aOutAllowed)
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
NS_ENSURE_ARG(aOutAllowed);
// We disallow persistent storage for the NodeId used for shared GMP
// decoding, to prevent GMP decoding being used to track what a user
@ -1133,7 +1133,7 @@ GeckoMediaPluginServiceParent::GetNodeId(const nsAString& aOrigin,
const nsAString& aGMPName,
nsACString& aOutId)
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
LOGD(("%s::%s: (%s, %s)", __CLASS__, __FUNCTION__,
NS_ConvertUTF16toUTF8(aOrigin).get(),
NS_ConvertUTF16toUTF8(aTopLevelOrigin).get()));
@ -1490,7 +1490,7 @@ void
GeckoMediaPluginServiceParent::ForgetThisSiteOnGMPThread(const nsACString& aSite,
const mozilla::OriginAttributesPattern& aPattern)
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
LOGD(("%s::%s: origin=%s", __CLASS__, __FUNCTION__, aSite.Data()));
struct OriginFilter : public DirectoryFilter {
@ -1513,7 +1513,7 @@ GeckoMediaPluginServiceParent::ForgetThisSiteOnGMPThread(const nsACString& aSite
void
GeckoMediaPluginServiceParent::ClearRecentHistoryOnGMPThread(PRTime aSince)
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
LOGD(("%s::%s: since=%" PRId64, __CLASS__, __FUNCTION__, (int64_t)aSince));
struct MTimeFilter : public DirectoryFilter {
@ -1673,7 +1673,7 @@ GeckoMediaPluginServiceParent::ServiceUserDestroyed(
void
GeckoMediaPluginServiceParent::ClearStorage()
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
LOGD(("%s::%s", __CLASS__, __FUNCTION__));
// Kill plugins with valid nodeIDs.

12
dom/media/gmp/GMPTimerParent.cpp
Просмотреть файл

@ -26,8 +26,8 @@ extern LogModule* GetGMPLog();
namespace gmp {
GMPTimerParent::GMPTimerParent(nsIThread* aGMPThread)
: mGMPThread(aGMPThread)
GMPTimerParent::GMPTimerParent(nsISerialEventTarget* aGMPEventTarget)
: mGMPEventTarget(aGMPEventTarget)
, mIsOpen(true)
{
}
@ -38,7 +38,7 @@ GMPTimerParent::RecvSetTimer(const uint32_t& aTimerId,
{
LOGD(("%s::%s: %p mIsOpen=%d", __CLASS__, __FUNCTION__, this, mIsOpen));
MOZ_ASSERT(mGMPThread == NS_GetCurrentThread());
MOZ_ASSERT(mGMPEventTarget->IsOnCurrentThread());
if (!mIsOpen) {
return IPC_OK();
@ -50,7 +50,7 @@ GMPTimerParent::RecvSetTimer(const uint32_t& aTimerId,
NS_ENSURE_SUCCESS(rv, IPC_OK());
ctx->mId = aTimerId;
rv = ctx->mTimer->SetTarget(mGMPThread);
rv = ctx->mTimer->SetTarget(mGMPEventTarget);
NS_ENSURE_SUCCESS(rv, IPC_OK());
ctx->mParent = this;
@ -70,7 +70,7 @@ GMPTimerParent::Shutdown()
{
LOGD(("%s::%s: %p mIsOpen=%d", __CLASS__, __FUNCTION__, this, mIsOpen));
MOZ_ASSERT(mGMPThread == NS_GetCurrentThread());
MOZ_ASSERT(mGMPEventTarget->IsOnCurrentThread());
for (auto iter = mTimers.Iter(); !iter.Done(); iter.Next()) {
Context* context = iter.Get()->GetKey();
@ -106,7 +106,7 @@ void
GMPTimerParent::TimerExpired(Context* aContext)
{
LOGD(("%s::%s: %p mIsOpen=%d", __CLASS__, __FUNCTION__, this, mIsOpen));
MOZ_ASSERT(mGMPThread == NS_GetCurrentThread());
MOZ_ASSERT(mGMPEventTarget->IsOnCurrentThread());
if (!mIsOpen) {
return;

4
dom/media/gmp/GMPTimerParent.h
Просмотреть файл

@ -20,7 +20,7 @@ namespace gmp {
class GMPTimerParent : public PGMPTimerParent {
public:
NS_INLINE_DECL_REFCOUNTING(GMPTimerParent)
explicit GMPTimerParent(nsIThread* aGMPThread);
explicit GMPTimerParent(nsISerialEventTarget* aGMPEventTarget);
void Shutdown();
@ -50,7 +50,7 @@ private:
nsTHashtable<nsPtrHashKey<Context>> mTimers;
nsCOMPtr<nsIThread> mGMPThread;
nsCOMPtr<nsISerialEventTarget> mGMPEventTarget;
bool mIsOpen;
};

18
dom/media/gmp/GMPVideoDecoderParent.cpp
Просмотреть файл

@ -73,7 +73,7 @@ void
GMPVideoDecoderParent::Close()
{
LOGD(("GMPVideoDecoderParent[%p]::Close()", this));
MOZ_ASSERT(!mPlugin || mPlugin->GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(!mPlugin || mPlugin->GMPEventTarget()->IsOnCurrentThread());
// Ensure if we've received a Close while waiting for a ResetComplete
// or DrainComplete notification, we'll unblock the caller before processing
@ -108,7 +108,7 @@ GMPVideoDecoderParent::InitDecode(const GMPVideoCodec& aCodecSettings,
return NS_ERROR_FAILURE;
}
MOZ_ASSERT(mPlugin->GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(mPlugin->GMPEventTarget()->IsOnCurrentThread());
if (!aCallback) {
return NS_ERROR_FAILURE;
@ -152,7 +152,7 @@ GMPVideoDecoderParent::Decode(GMPUniquePtr<GMPVideoEncodedFrame> aInputFrame,
return NS_ERROR_FAILURE;
}
MOZ_ASSERT(mPlugin->GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(mPlugin->GMPEventTarget()->IsOnCurrentThread());
GMPUniquePtr<GMPVideoEncodedFrameImpl> inputFrameImpl(
static_cast<GMPVideoEncodedFrameImpl*>(aInputFrame.release()));
@ -193,7 +193,7 @@ GMPVideoDecoderParent::Reset()
return NS_ERROR_FAILURE;
}
MOZ_ASSERT(mPlugin->GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(mPlugin->GMPEventTarget()->IsOnCurrentThread());
if (!SendReset()) {
return NS_ERROR_FAILURE;
@ -209,8 +209,8 @@ GMPVideoDecoderParent::Reset()
LogToBrowserConsole(NS_LITERAL_STRING("GMPVideoDecoderParent timed out waiting for ResetComplete()"));
});
CancelResetCompleteTimeout();
nsCOMPtr<nsIThread> thread = mPlugin->GMPThread();
mResetCompleteTimeout = SimpleTimer::Create(task, 5000, thread);
nsCOMPtr<nsISerialEventTarget> target = mPlugin->GMPEventTarget();
mResetCompleteTimeout = SimpleTimer::Create(task, 5000, target);
// Async IPC, we don't have access to a return value.
return NS_OK;
@ -235,7 +235,7 @@ GMPVideoDecoderParent::Drain()
return NS_ERROR_FAILURE;
}
MOZ_ASSERT(mPlugin->GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(mPlugin->GMPEventTarget()->IsOnCurrentThread());
if (!SendDrain()) {
return NS_ERROR_FAILURE;
@ -254,7 +254,7 @@ GMPVideoDecoderParent::GetDisplayName() const
NS_WARNING("Trying to use an dead GMP video decoder");
}
MOZ_ASSERT(mPlugin->GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(mPlugin->GMPEventTarget()->IsOnCurrentThread());
return mPlugin->GetDisplayName();
}
@ -264,7 +264,7 @@ nsresult
GMPVideoDecoderParent::Shutdown()
{
LOGD(("GMPVideoDecoderParent[%p]::Shutdown()", this));
MOZ_ASSERT(!mPlugin || mPlugin->GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(!mPlugin || mPlugin->GMPEventTarget()->IsOnCurrentThread());
if (mShuttingDown) {
return NS_OK;

14
dom/media/gmp/GMPVideoEncoderParent.cpp
Просмотреть файл

@ -83,7 +83,7 @@ void
GMPVideoEncoderParent::Close()
{
LOGD(("%s::%s: %p", __CLASS__, __FUNCTION__, this));
MOZ_ASSERT(mPlugin->GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(mPlugin->GMPEventTarget()->IsOnCurrentThread());
// Consumer is done with us; we can shut down. No more callbacks should
// be made to mCallback. Note: do this before Shutdown()!
mCallback = nullptr;
@ -108,7 +108,7 @@ GMPVideoEncoderParent::InitEncode(const GMPVideoCodec& aCodecSettings,
return GMPGenericErr;;
}
MOZ_ASSERT(mPlugin->GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(mPlugin->GMPEventTarget()->IsOnCurrentThread());
if (!aCallback) {
return GMPGenericErr;
@ -134,7 +134,7 @@ GMPVideoEncoderParent::Encode(GMPUniquePtr<GMPVideoi420Frame> aInputFrame,
return GMPGenericErr;
}
MOZ_ASSERT(mPlugin->GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(mPlugin->GMPEventTarget()->IsOnCurrentThread());
GMPUniquePtr<GMPVideoi420FrameImpl> inputFrameImpl(
static_cast<GMPVideoi420FrameImpl*>(aInputFrame.release()));
@ -168,7 +168,7 @@ GMPVideoEncoderParent::SetChannelParameters(uint32_t aPacketLoss, uint32_t aRTT)
return GMPGenericErr;
}
MOZ_ASSERT(mPlugin->GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(mPlugin->GMPEventTarget()->IsOnCurrentThread());
if (!SendSetChannelParameters(aPacketLoss, aRTT)) {
return GMPGenericErr;
@ -186,7 +186,7 @@ GMPVideoEncoderParent::SetRates(uint32_t aNewBitRate, uint32_t aFrameRate)
return GMPGenericErr;
}
MOZ_ASSERT(mPlugin->GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(mPlugin->GMPEventTarget()->IsOnCurrentThread());
if (!SendSetRates(aNewBitRate, aFrameRate)) {
return GMPGenericErr;
@ -204,7 +204,7 @@ GMPVideoEncoderParent::SetPeriodicKeyFrames(bool aEnable)
return GMPGenericErr;
}
MOZ_ASSERT(mPlugin->GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(mPlugin->GMPEventTarget()->IsOnCurrentThread());
if (!SendSetPeriodicKeyFrames(aEnable)) {
return GMPGenericErr;
@ -219,7 +219,7 @@ void
GMPVideoEncoderParent::Shutdown()
{
LOGD(("%s::%s: %p", __CLASS__, __FUNCTION__, this));
MOZ_ASSERT(mPlugin->GMPThread() == NS_GetCurrentThread());
MOZ_ASSERT(mPlugin->GMPEventTarget()->IsOnCurrentThread());
if (mShuttingDown) {
return;

4
dom/media/platforms/PDMFactory.cpp
Просмотреть файл

@ -189,7 +189,7 @@ PDMFactory::EnsureInit() const
}
// Not on the main thread -> Sync-dispatch creation to main thread.
nsCOMPtr<nsIThread> mainThread = do_GetMainThread();
nsCOMPtr<nsIEventTarget> mainTarget = GetMainThreadEventTarget();
nsCOMPtr<nsIRunnable> runnable =
NS_NewRunnableFunction([]() {
StaticMutexAutoLock mon(sMonitor);
@ -198,7 +198,7 @@ PDMFactory::EnsureInit() const
ClearOnShutdown(&sInstance);
}
});
SyncRunnable::DispatchToThread(mainThread, runnable);
SyncRunnable::DispatchToThread(mainTarget, runnable);
}
already_AddRefed<MediaDataDecoder>

2
dom/media/platforms/agnostic/gmp/GMPVideoDecoder.cpp
Просмотреть файл

@ -25,7 +25,7 @@ static bool IsOnGMPThread()
nsCOMPtr<nsIThread> gmpThread;
nsresult rv = mps->GetThread(getter_AddRefs(gmpThread));
MOZ_ASSERT(NS_SUCCEEDED(rv) && gmpThread);
return NS_GetCurrentThread() == gmpThread;
return gmpThread->EventTarget()->IsOnCurrentThread();
}
#endif

33
dom/media/systemservices/CamerasParent.cpp
Просмотреть файл

@ -63,9 +63,9 @@ void InputObserver::OnDeviceChange() {
return NS_OK;
});
nsIThread* thread = mParent->GetBackgroundThread();
MOZ_ASSERT(thread != nullptr);
thread->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL);
nsIEventTarget* target = mParent->GetBackgroundEventTarget();
MOZ_ASSERT(target != nullptr);
target->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL);
};
class DeliverFrameRunnable : public ::mozilla::Runnable {
@ -281,9 +281,9 @@ CallbackHelper::RenderFrame(uint32_t aStreamId, const webrtc::VideoFrame& aVideo
aVideoFrame, properties);
}
MOZ_ASSERT(mParent);
nsIThread* thread = mParent->GetBackgroundThread();
MOZ_ASSERT(thread != nullptr);
thread->Dispatch(runnable, NS_DISPATCH_NORMAL);
nsIEventTarget* target = mParent->GetBackgroundEventTarget();
MOZ_ASSERT(target != nullptr);
target->Dispatch(runnable, NS_DISPATCH_NORMAL);
return 0;
}
@ -457,7 +457,7 @@ CamerasParent::RecvNumberOfCaptureDevices(const CaptureEngine& aCapEngine)
return NS_OK;
}
});
self->mPBackgroundThread->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL);
self->mPBackgroundEventTarget->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL);
return NS_OK;
});
DispatchToVideoCaptureThread(webrtc_runnable);
@ -489,7 +489,7 @@ CamerasParent::RecvEnsureInitialized(const CaptureEngine& aCapEngine)
return NS_OK;
}
});
self->mPBackgroundThread->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL);
self->mPBackgroundEventTarget->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL);
return NS_OK;
});
DispatchToVideoCaptureThread(webrtc_runnable);
@ -527,7 +527,7 @@ CamerasParent::RecvNumberOfCapabilities(const CaptureEngine& aCapEngine,
Unused << self->SendReplyNumberOfCapabilities(num);
return NS_OK;
});
self->mPBackgroundThread->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL);
self->mPBackgroundEventTarget->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL);
return NS_OK;
});
DispatchToVideoCaptureThread(webrtc_runnable);
@ -578,7 +578,7 @@ CamerasParent::RecvGetCaptureCapability(const CaptureEngine& aCapEngine,
Unused << self->SendReplyGetCaptureCapability(capCap);
return NS_OK;
});
self->mPBackgroundThread->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL);
self->mPBackgroundEventTarget->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL);
return NS_OK;
});
DispatchToVideoCaptureThread(webrtc_runnable);
@ -629,7 +629,7 @@ CamerasParent::RecvGetCaptureDevice(const CaptureEngine& aCapEngine,
Unused << self->SendReplyGetCaptureDevice(name, uniqueId, scary);
return NS_OK;
});
self->mPBackgroundThread->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL);
self->mPBackgroundEventTarget->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL);
return NS_OK;
});
DispatchToVideoCaptureThread(webrtc_runnable);
@ -740,7 +740,7 @@ CamerasParent::RecvAllocateCaptureDevice(const CaptureEngine& aCapEngine,
return NS_OK;
}
});
self->mPBackgroundThread->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL);
self->mPBackgroundEventTarget->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL);
return NS_OK;
});
self->DispatchToVideoCaptureThread(webrtc_runnable);
@ -788,7 +788,7 @@ CamerasParent::RecvReleaseCaptureDevice(const CaptureEngine& aCapEngine,
return NS_OK;
}
});
self->mPBackgroundThread->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL);
self->mPBackgroundEventTarget->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL);
return NS_OK;
});
DispatchToVideoCaptureThread(webrtc_runnable);
@ -854,7 +854,7 @@ CamerasParent::RecvStartCapture(const CaptureEngine& aCapEngine,
return NS_ERROR_FAILURE;
}
});
self->mPBackgroundThread->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL);
self->mPBackgroundEventTarget->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL);
return NS_OK;
});
DispatchToVideoCaptureThread(webrtc_runnable);
@ -966,8 +966,9 @@ CamerasParent::CamerasParent()
{
LOG(("CamerasParent: %p", this));
mPBackgroundThread = NS_GetCurrentThread();
MOZ_ASSERT(mPBackgroundThread != nullptr, "GetCurrentThread failed");
mPBackgroundEventTarget = GetCurrentThreadSerialEventTarget();
MOZ_ASSERT(mPBackgroundEventTarget != nullptr,
"GetCurrentThreadEventTarget failed");
LOG(("Spinning up WebRTC Cameras Thread"));

4
dom/media/systemservices/CamerasParent.h
Просмотреть файл

@ -113,7 +113,7 @@ public:
virtual void ActorDestroy(ActorDestroyReason aWhy) override;
virtual mozilla::ipc::IPCResult RecvEnsureInitialized(const CaptureEngine&) override;
nsIThread* GetBackgroundThread() { return mPBackgroundThread; };
nsIEventTarget* GetBackgroundEventTarget() { return mPBackgroundEventTarget; };
bool IsShuttingDown() { return !mChildIsAlive
|| mDestroyed
|| !mWebRTCAlive; };
@ -151,7 +151,7 @@ protected:
mozilla::ShmemPool mShmemPool;
// PBackground parent thread
nsCOMPtr<nsIThread> mPBackgroundThread;
nsCOMPtr<nsISerialEventTarget> mPBackgroundEventTarget;
// Monitors creation of the thread below
Monitor mThreadMonitor;

6
dom/media/webaudio/blink/HRTFDatabaseLoader.cpp
Просмотреть файл

@ -123,11 +123,11 @@ private:
void HRTFDatabaseLoader::ProxyRelease()
{
nsCOMPtr<nsIThread> mainThread = do_GetMainThread();
if (MOZ_LIKELY(mainThread)) {
nsCOMPtr<nsIEventTarget> mainTarget = GetMainThreadEventTarget();
if (MOZ_LIKELY(mainTarget)) {
RefPtr<ProxyReleaseEvent> event = new ProxyReleaseEvent(this);
DebugOnly<nsresult> rv =
mainThread->Dispatch(event, NS_DISPATCH_NORMAL);
mainTarget->Dispatch(event, NS_DISPATCH_NORMAL);
MOZ_ASSERT(NS_SUCCEEDED(rv), "Failed to dispatch release event");
} else {
// Should be in XPCOM shutdown.

5
dom/media/webspeech/recognition/SpeechStreamListener.cpp
Просмотреть файл

@ -19,10 +19,7 @@ SpeechStreamListener::SpeechStreamListener(SpeechRecognition* aRecognition)
SpeechStreamListener::~SpeechStreamListener()
{
nsCOMPtr<nsIThread> mainThread;
NS_GetMainThread(getter_AddRefs(mainThread));
NS_ProxyRelease(mainThread, mRecognition.forget());
NS_ReleaseOnMainThread(mRecognition.forget());
}
void

11
dom/network/TCPSocket.cpp
Просмотреть файл

@ -200,10 +200,8 @@ TCPSocket::CreateStream()
nsCOMPtr<nsIAsyncInputStream> asyncStream = do_QueryInterface(mSocketInputStream);
NS_ENSURE_TRUE(asyncStream, NS_ERROR_NOT_AVAILABLE);
nsCOMPtr<nsIThread> mainThread;
NS_GetMainThread(getter_AddRefs(mainThread));
rv = asyncStream->AsyncWait(this, nsIAsyncInputStream::WAIT_CLOSURE_ONLY, 0, mainThread);
nsCOMPtr<nsIEventTarget> mainTarget = GetMainThreadEventTarget();
rv = asyncStream->AsyncWait(this, nsIAsyncInputStream::WAIT_CLOSURE_ONLY, 0, mainTarget);
NS_ENSURE_SUCCESS(rv, rv);
if (mUseArrayBuffers) {
@ -248,9 +246,8 @@ TCPSocket::InitWithUnconnectedTransport(nsISocketTransport* aTransport)
MOZ_ASSERT(XRE_GetProcessType() != GeckoProcessType_Content);
nsCOMPtr<nsIThread> mainThread;
NS_GetMainThread(getter_AddRefs(mainThread));
mTransport->SetEventSink(this, mainThread);
nsCOMPtr<nsIEventTarget> mainTarget = GetMainThreadEventTarget();
mTransport->SetEventSink(this, mainTarget);
nsresult rv = CreateStream();
NS_ENSURE_SUCCESS(rv, rv);

4
dom/network/UDPSocketParent.cpp
Просмотреть файл

@ -241,13 +241,13 @@ static void CheckSTSThread()
mozilla::ipc::IPCResult
UDPSocketParent::RecvConnect(const UDPAddressInfo& aAddressInfo)
{
nsCOMPtr<nsIEventTarget> thread(NS_GetCurrentThread());
nsCOMPtr<nsIEventTarget> target = GetCurrentThreadEventTarget();
Unused <<
NS_WARN_IF(NS_FAILED(GetSTSThread()->Dispatch(WrapRunnable(
RefPtr<UDPSocketParent>(this),
&UDPSocketParent::DoConnect,
mSocket,
thread,
target,
aAddressInfo),
NS_DISPATCH_NORMAL)));
return IPC_OK();

6
dom/notification/Notification.cpp
Просмотреть файл

@ -2724,9 +2724,9 @@ Notification::DispatchToMainThread(already_AddRefed<nsIRunnable>&& aRunnable)
return target->Dispatch(Move(aRunnable), nsIEventTarget::DISPATCH_NORMAL);
}
}
nsCOMPtr<nsIThread> mainThread = do_GetMainThread();
MOZ_ASSERT(mainThread);
return mainThread->Dispatch(Move(aRunnable), nsIEventTarget::DISPATCH_NORMAL);
nsCOMPtr<nsIEventTarget> mainTarget = GetMainThreadEventTarget();
MOZ_ASSERT(mainTarget);
return mainTarget->Dispatch(Move(aRunnable), nsIEventTarget::DISPATCH_NORMAL);
}
} // namespace dom

12
dom/presentation/PresentationTCPSessionTransport.cpp
Просмотреть файл

@ -180,10 +180,8 @@ PresentationTCPSessionTransport::BuildTCPReceiverTransport(nsIPresentationChanne
return rv;
}
nsCOMPtr<nsIThread> mainThread;
NS_GetMainThread(getter_AddRefs(mainThread));
mTransport->SetEventSink(this, mainThread);
nsCOMPtr<nsIEventTarget> mainTarget = GetMainThreadEventTarget();
mTransport->SetEventSink(this, mainTarget);
rv = CreateStream();
if (NS_WARN_IF(NS_FAILED(rv))) {
@ -220,10 +218,8 @@ PresentationTCPSessionTransport::CreateStream()
return NS_ERROR_NOT_AVAILABLE;
}
nsCOMPtr<nsIThread> mainThread;
NS_GetMainThread(getter_AddRefs(mainThread));
rv = asyncStream->AsyncWait(this, nsIAsyncInputStream::WAIT_CLOSURE_ONLY, 0, mainThread);
nsCOMPtr<nsIEventTarget> mainTarget = GetMainThreadEventTarget();
rv = asyncStream->AsyncWait(this, nsIAsyncInputStream::WAIT_CLOSURE_ONLY, 0, mainTarget);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}

2
dom/quota/ActorsChild.cpp
Просмотреть файл

@ -22,7 +22,7 @@ namespace quota {
QuotaChild::QuotaChild(QuotaManagerService* aService)
: mService(aService)
#ifdef DEBUG
, mOwningThread(NS_GetCurrentThread())
, mOwningThread(GetCurrentThreadEventTarget())
#endif
{
AssertIsOnOwningThread();

Некоторые файлы не были показаны из-за слишком большого количества измененных файлов Показать больше